from pymel.core.uitypes import TextFieldButtonGrp
from pymel.core.uitypes import DefaultLightListCheckBox
from pymel.core.uitypes import CheckBoxGrp
from pymel.core.uitypes import BlendShapePanel
from pymel.core.uitypes import IntSlider
from pymel.core.uitypes import ShelfTabLayout
from pymel.core.uitypes import ShelfButton
from pymel.core.uitypes import ChannelBox
from pymel.core.uitypes import AnimCurveEditor
from pymel.util.enum import Enum
from pymel.core.uitypes import CheckBox
from pymel.core.uitypes import GridLayout
from pymel.core.uitypes import PaneLayout
from pymel.core.uitypes import IntField
from pymel.core.uitypes import IntFieldGrp
from pymel.core.uitypes import PalettePort
from pymel.core.uitypes import ColorEditor
from pymel.core.uitypes import DynRelEdPanel
from pymel.core.uitypes import IconTextRadioCollection
from pymel.core.uitypes import LayoutDialog
from pymel.core.uitypes import PromptDialog
from pymel.core.uitypes import FloatSliderGrp
from pymel.core.uitypes import ConfirmDialog
from pymel.core.uitypes import IconTextCheckBox
from pymel.core.uitypes import RadioMenuItemCollection
from pymel.core.uitypes import IconTextScrollList
from pymel.core.uitypes import ScrollField
from pymel.core.uitypes import HyperGraph
from pymel.core.uitypes import AttrFieldSliderGrp
from pymel.core.uitypes import IconTextStaticLabel
from pymel.core.uitypes import OutlinerEditor
from pymel.core.uitypes import Text
from pymel.core.uitypes import RadioButtonGrp
from maya.OpenMaya import MSelectionList as _MSelectionList
from pymel.core.uitypes import HyperShade
from pymel.core.uitypes import Visor
from pymel.core.uitypes import RadioButton
from pymel.core.uitypes import FloatScrollBar
from pymel.core.uitypes import RenderLayerButton
from pymel.core.uitypes import CmdScrollFieldExecuter
from pymel.core.uitypes import BlendShapeEditor
from pymel.core.uitypes import Canvas
from pymel.core.uitypes import MenuBarLayout
from pymel.core.uitypes import FloatSlider
from pymel.core.uitypes import FrameLayout
from pymel.core.uitypes import FloatField
from pymel.core.uitypes import NodeIconButton
from pymel.core.uitypes import SymbolCheckBox
from pymel.core.uitypes import DevicePanel
from pymel.core.uitypes import ScrollLayout
from pymel.core.uitypes import GlRenderEditor
from pymel.core.uitypes import TextFieldGrp
from pymel.core.uitypes import ModelPanel
from pymel.core.uitypes import ProgressBar
from pymel.core.uitypes import FloatSliderButtonGrp
from pymel.core.uitypes import ScriptedPanelType
from pymel.core.uitypes import ScriptedPanel
from pymel.core.uitypes import Button
from pymel.core.uitypes import OutlinerPanel
from pymel.core.uitypes import ToolCollection
from pymel.core.uitypes import ColorSliderButtonGrp
from pymel.core.uitypes import Image
from pymel.core.uitypes import ModelEditor
from pymel.core.uitypes import AttrFieldGrp
from pymel.core.uitypes import Separator
from pymel.core.uitypes import ColorSliderGrp
from pymel.core.uitypes import AnimDisplay
from pymel.core.uitypes import CmdScrollFieldReporter
from pymel.core.uitypes import IconTextRadioButton
from pymel.core.uitypes import RowColumnLayout
from pymel.core.uitypes import HelpLine
from pymel.core.uitypes import HyperPanel
from pymel.core.uitypes import MenuSet
from pymel.core.uitypes import ShelfLayout
from pymel.core.uitypes import DynPaintEditor
from pymel.core.uitypes import AttrColorSliderGrp
from pymel.core.uitypes import SymbolButton
from pymel.core.uitypes import TextCurves
from pymel.core.animation import listAnimatable as _listAnimatable
from pymel.internal.plogging import getLogger as _getLogger
from pymel.core.uitypes import AttrEnumOptionMenuGrp
from pymel.core.uitypes import AttrEnumOptionMenu
from pymel.core.uitypes import KeyframeStats
from pymel.core.uitypes import FontDialog
from pymel.core.uitypes import AttributeMenu
from pymel.core.uitypes import NameField
from pymel.core.uitypes import FloatSlider2
from pymel.core.uitypes import GradientControlNoAttr
from pymel.core.uitypes import ToolButton
from pymel.core.uitypes import FloatFieldGrp
from pymel.core.uitypes import ColumnLayout
from pymel.core.uitypes import TabLayout
from pymel.core.uitypes import GradientControl
from pymel.core.uitypes import AttrNavigationControlGrp
from pymel.core.uitypes import RenderWindowEditor
from pymel.core.uitypes import ShellField
from pymel.core.uitypes import ClipSchedulerOutliner
from pymel.core.system import FileReference as _FileReference
from pymel.core.uitypes import AttrControlGrp
from pymel.core.uitypes import DeviceEditor
from pymel.core.uitypes import MenuEditor
from pymel.core.system import namespaceInfo as _namespaceInfo
from pymel.core.uitypes import HardwareRenderPanel
from pymel.core.uitypes import ClipEditor
from pymel.core.uitypes import DynRelEditor
from pymel.core.uitypes import MessageLine
from pymel.core.uitypes import IconTextButton
from pymel.core.uitypes import ColorIndexSliderGrp
from pymel.core.uitypes import KeyframeOutliner
from pymel.core.uitypes import ExclusiveLightCheckBox
from pymel.core.uitypes import TextField
from pymel.core.uitypes import CmdShell
from pymel.core.uitypes import ScriptTable
from pymel.core.uitypes import CommandLine
from pymel.core.uitypes import LayerButton
from pymel.core.uitypes import IntScrollBar
from pymel.core.uitypes import RadioCollection
from pymel.core.uitypes import IntSliderGrp


if False:
    from typing import Dict, List, Tuple, Union, Optional

class SelectionSet(_MSelectionList):
    def __and__(self, s):
        """
        operator for `SelectionSet.getIntersection`
        """
        pass
    def __contains__(self, item):
        """
        Returns
        -------
        bool
        """
        pass
    def __getitem__(self, index):
        """
        Returns
        -------
        general.PyNode
        """
        pass
    def __gt__(self, s):
        """
        operator for `SelectionSet.isSuperSet`
        """
        pass
    def __iand__(self, s):
        """
        operator for `SelectionSet.intersection`
        """
        pass
    def __init__(self, objs):
        """
        can be initialized from a list of objects, another SelectionSet, an MSelectionList, or an ObjectSet
        """
        pass
    def __ior__(self, s):
        """
        operator for `SelectionSet.union`
        """
        pass
    def __isub__(self, s):
        """
        operator for `SelectionSet.difference`
        """
        pass
    def __ixor__(self, s):
        """
        operator for `SelectionSet.symmetricDifference`
        """
        pass
    def __len__(self):
        """
        Returns
        -------
        int
        """
        pass
    def __lt__(self, s):
        """
        operator for `SelectionSet.isSubSet`
        """
        pass
    def __melobject__(self): pass
    def __or__(self, s):
        """
        operator for `SelectionSet.getUnion`
        """
        pass
    def __repr__(self):
        """
        Returns
        -------
        str
        """
        pass
    def __setitem__(self, index, item): pass
    def __sub__(self, s):
        """
        operator for `SelectionSet.getDifference`
        """
        pass
    def __xor__(self, s):
        """
        operator for `SelectionSet.symmetricDifference`
        """
        pass
    def add(self, item): pass
    def asObjectSet(self): pass
    def clear(self):
        """
        This method empties the selection list.
        Derived from api method `maya.OpenMaya.MSelectionList.clear`
        """
        pass
    def difference(self, other): pass
    def getDifference(self, other):
        """
        Returns
        -------
        SelectionSet
        """
        pass
    def getIntersection(self, other):
        """
        Returns
        -------
        SelectionSet
        """
        pass
    def getSelectionStrings(self):
        """
        Gets the string representations of the items in the selection list. The strings will be in the format used by the scripting language.
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MSelectionList.getSelectionStrings`
        """
        pass
    def getSymmetricDifference(self, other):
        """
        Also known as XOR
        
        Returns
        -------
        SelectionSet
        """
        pass
    def getUnion(self, other):
        """
        Returns
        -------
        SelectionSet
        """
        pass
    def intersect(self, other, expandToLeaves='False'):
        """
        Modify this list to contain the intersection of itself and the given list.
        
        Parameters:
        other : 'SelectionSet'
            the selection list to be intersected.
        expandToLeaves : 'bool'
            If expandToLeaves is true, the two lists will be copied and grown to include leaf nodes before performing the intersection.
        
        Derived from api method `maya.OpenMaya.MSelectionList.intersect`
        """
        pass
    def intersection(self, other): pass
    def isEmpty(self):
        """
        Specifies whether or not the selection list contains any items.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MSelectionList.isEmpty`
        """
        pass
    def isSubSet(self, other):
        """
        Returns
        -------
        bool
        """
        pass
    def isSuperSet(self, other, flatten='True'):
        """
        Returns
        -------
        bool
        """
        pass
    def pop(self, index):
        """
        Parameters
        ----------
        index : int
        
        Returns
        -------
        general.PyNode
        """
        pass
    def removeAtIndex(self, index):
        """
        Removes the item at the given index from the list.
        
        Parameters:
        index : 'int'
            The index of the item to be removed
        
        Derived from api method `maya.OpenMaya.MSelectionList.remove`
        """
        pass
    def symmetricDifference(self, other): pass
    def union(self, other): pass
    MergeStrategy = {}
    
    
    
    
    __readonly__ = {}
    
    
    apicls = None


from . import general

class DependNode(general.PyNode):
    def __apihandle__(self):
        """
        get the ``maya.OpenMaya.MObjectHandle`` for this node if it is valid
        """
        pass
    def __apimobject__(self):
        """
        get the ``maya.OpenMaya.MObject`` for this node if it is valid
        """
        pass
    def __apiobject__(self):
        """
        get the default API object (MObject) for this node if it is valid
        """
        pass
    def __getattr__(self, attr): pass
    def __hash__(self): pass
    def __melobject__(*args, **kwargs):
        """
        Special method for returning a mel-friendly representation.
        """
        pass
    def __repr__(self):
        """
        Returns
        -------
        unicode
        """
        pass
    def __str__(self): pass
    def __unicode__(self): pass
    def absoluteName(self):
        """
        Returns the absolute name of this node.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.absoluteName`
        """
        pass
    def addAttr(self, attr, **kwargs):
        """
        This command is used to add a dynamic attribute to a node or nodes. Either the
        longName or the shortName or both must be specified. If neither a dataType nor
        an attributeType is specified, a double attribute will be added.  The dataType
        flag can be specified more than once indicating that any of the supplied types
        will be accepted (logical-or).  To add a non-double attribute the following
        criteria can be used to determine whether the dataType or the attributeType flag
        is appropriate.  Some types, such as double3can use either. In these cases the
        -dtflag should be used when you only wish to access the data as an atomic entity
        (eg. you never want to access the three individual values that make up a
        double3).  In general it is best to use the -atin these cases for maximum
        flexibility. In most cases the -dtversion will not display in the attribute
        editor as it is an atomic type and you are not allowed to change individual
        parts of it.  All attributes flagged as (compound)below or the compound
        attribute itself are not actually added to the node until all of the children
        are defined (using the -pflag to set their parent to the compound being
        created).  See the EXAMPLES section for more details.  Type of attribute
        Flag and argument to use      boolean
        -at bool                      32 bit integer                                 -at
        long                      16 bit integer                                 -at
        short                     8 bit integer                                  -at
        byte                      char
        -at char                      enum
        -at enum (specify the enum names using the enumName flag) float
        -at float(use quotes
        since float is a mel keyword)   double
        -at double            angle value                                    -at
        doubleAngle       linear value                                   -at
        doubleLinear      string                                                 -dt
        string(use quotes
        since string is a mel keyword)  array of strings
        -dt stringArray       compound                                               -at
        compound          message (no data)                              -at message
        time                                                   -at time
        4x4 double matrix                              -dt matrix(use quotes
        since matrix is a mel keyword)  4x4 float matrix
        -at fltMatrix         reflectance                                    -dt
        reflectanceRGBreflectance (compound)                 -at reflectance
        spectrum                                               -dt spectrumRGB
        spectrum (compound)                    -at spectrum          2 floats
        -dt float2            2 floats (compound)                    -at float2
        3 floats                                               -dt float3            3
        floats (compound)                    -at float3            2 doubles
        -dt double2           2 doubles (compound)                   -at double2
        3 doubles                                              -dt double3           3
        doubles (compound)                   -at double3           2 32-bit integers
        -dt long2                     2 32-bit integers (compound)   -at long2
        3 32-bit integers                              -dt long3                     3
        32-bit integers (compound)   -at long3                     2 16-bit integers
        -dt short2            2 16-bit integers (compound)   -at short2            3
        16-bit integers                              -dt short3            3 16-bit
        integers (compound)   -at short3            array of doubles
        -dt doubleArray       array of floats                                -dt
        floatArray        array of 32-bit ints                   -dt Int32Array
        array of vectors                               -dt vectorArray       nurbs curve
        -dt nurbsCurve        nurbs surface                                  -dt
        nurbsSurface      polygonal mesh                                 -dt mesh
        lattice                                                -dt lattice
        array of double 4D points              -dt pointArray        In query mode,
        return type is based on queried flag.
        
        Flags:
        - attributeType : at             (unicode)       [create,query]
            Specifies the attribute type, see above table for more details. Note that the
            attribute types float, matrixand stringare also MEL keywords and must be
            enclosed in quotes.
        
        - binaryTag : bt                 (unicode)       [create,query]
            This flag is obsolete and does not do anything any more
        
        - cachedInternally : ci          (bool)          [create,query]
            Whether or not attribute data is cached internally in the node. This flag
            defaults to true for writable attributes and false for non-writable attributes.
            A warning will be issued if users attempt to force a writable attribute to be
            uncached as this will make it impossible to set keyframes.
        
        - category : ct                  (unicode)       [create,query,edit]
            An attribute category is a string associated with the attribute to identify it.
            (e.g. the name of a plugin that created the attribute, version information,
            etc.) Any attribute can be associated with an arbitrary number of categories
            however categories can not be removed once associated.
        
        - dataType : dt                  (unicode)       [create,query]
            Specifies the data type.  See setAttrfor more information on data type names.
        
        - defaultValue : dv              (float)         [create,query,edit]
            Specifies the default value for the attribute (can only be used for numeric
            attributes).
        
        - disconnectBehaviour : dcb      (int)           [create,query]
            defines the Disconnect Behaviour 2 Nothing, 1 Reset, 0 Delete
        
        - enumName : en                  (unicode)       [create,query,edit]
            Flag used to specify the ui names corresponding to the enum values. The
            specified string should contain a colon-separated list of the names, with
            optional values. If values are not specified, they will treated as sequential
            integers starting with 0. For example: -enumName A:B:Cwould produce options:
            A,B,C with values of 0,1,2; -enumName zero:one:two:thousand=1000would produce
            four options with values 0,1,2,1000; and -enumName
            solo=1:triplet=3:quintet=5would produce three options with values 1,3,5.  (Note
            that there is a current limitation of the Channel Box that will sometimes
            incorrectly display an enumerated attribute's pull-down menu.  Extra menu items
            can appear that represent the numbers inbetween non-sequential option values.
            To avoid this limitation, specify sequential values for the options of any
            enumerated attributes that will appear in the Channel Box.  For example:
            solo=1:triplet=2:quintet=3.)
        
        - exists : ex                    (bool)          [create,query]
            Returns true if the attribute queried is a user-added, dynamic attribute; false
            if not.
        
        - fromPlugin : fp                (bool)          [create,query]
            Was the attribute originally created by a plugin? Normally set automatically
            when the API call is made - only added here to support storing it in a file
            independently from the creating plugin.
        
        - hasMaxValue : hxv              (bool)          [create,query,edit]
            Flag indicating whether an attribute has a maximum value. (can only be used for
            numeric attributes).
        
        - hasMinValue : hnv              (bool)          [create,query,edit]
            Flag indicating whether an attribute has a minimum value. (can only be used for
            numeric attributes).
        
        - hasSoftMaxValue : hsx          (bool)          [create,query]
            Flag indicating whether a numeric attribute has a soft maximum.
        
        - hasSoftMinValue : hsn          (bool)          [create,query]
            Flag indicating whether a numeric attribute has a soft minimum.
        
        - hidden : h                     (bool)          [create,query]
            Will this attribute be hidden from the UI?
        
        - indexMatters : im              (bool)          [create,query]
            Sets whether an index must be used when connecting to this multi-attribute.
            Setting indexMatters to false forces the attribute to non-readable.
        
        - internalSet : internalSet      (bool)          [create,query]
            Whether or not the internal cached value is set when this attribute value is
            changed.  This is an internal flag used for updating UI elements.
        
        - keyable : k                    (bool)          [create,query]
            Is the attribute keyable by default?
        
        - longName : ln                  (unicode)       [create,query]
            Sets the long name of the attribute.
        
        - maxValue : max                 (float)         [create,query,edit]
            Specifies the maximum value for the attribute (can only be used for numeric
            attributes).
        
        - minValue : min                 (float)         [create,query,edit]
            Specifies the minimum value for the attribute (can only be used for numeric
            attributes).
        
        - multi : m                      (bool)          [create,query]
            Makes the new attribute a multi-attribute.
        
        - niceName : nn                  (unicode)       [create,query,edit]
            Sets the nice name of the attribute for display in the UI.  Setting the
            attribute's nice name to a non-empty string overrides the default behaviour of
            looking up the nice name from Maya's string catalog.   (Use the MEL commands
            attributeNiceNameand attributeQuery -niceNameto lookup an attribute's nice name
            in the catalog.)
        
        - numberOfChildren : nc          (int)           [create,query]
            How many children will the new attribute have?
        
        - parent : p                     (unicode)       [create,query]
            Attribute that is to be the new attribute's parent.
        
        - proxy : pxy                    (unicode)       [create,query]
            Proxy another node's attribute. Proxied plug will be connected as source. The
            UsedAsProxy flag is automatically set in this case.
        
        - readable : r                   (bool)          [create,query]
            Can outgoing connections be made from this attribute?
        
        - shortName : sn                 (unicode)       [create,query]
            Sets the short name of the attribute.
        
        - softMaxValue : smx             (float)         [create,query,edit]
            Soft maximum, valid for numeric attributes only.  Specifies the upper default
            limit used in sliders for this attribute.
        
        - softMinValue : smn             (float)         [create,query,edit]
            Soft minimum, valid for numeric attributes only.  Specifies the upper default
            limit used in sliders for this attribute.
        
        - storable : s                   (bool)          [create,query]
            Can the attribute be stored out to a file?
        
        - usedAsColor : uac              (bool)          [create,query]
            Is the attribute to be used as a color definition? Must have 3 DOUBLE or 3 FLOAT
            children to use this flag.  The attribute type -atshould be double3or float3as
            appropriate.  It can also be used to less effect with data types -dtas double3or
            float3as well but some parts of the code do not support this alternative.  The
            special attribute types/data spectrumand reflectancealso support the color flag
            and on them it is set by default.
        
        - usedAsFilename : uaf           (bool)          [create,query]
            Is the attribute to be treated as a filename definition? This flag is only
            supported on attributes with data type -dtof string.
        
        - usedAsProxy : uap              (bool)          [create,query]
            Set if the specified attribute should be treated as a proxy to another
            attributes.
        
        - writable : w                   (bool)          [create,query]
            Can incoming connections be made to this attribute?
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.addAttr`
        """
        pass
    def attr(self, attr):
        """
        access to attribute plug of a node. returns an instance of the Attribute class for the
        given attribute name.
        
        Returns
        -------
        general.Attribute
        """
        pass
    def attrDefaults(*args, **kwargs):
        """
        Access to an attribute specifications of a node.  This does not require
        an instance:
        
            >>> nt.Transform.attrSpec('tx').isKeyable()
            True
        
        but it can use one if needed ( for example, for dynamically created attributes )
        
            >>> nt.Transform(u'persp').attrSpec('tx').isKeyable()
        
        Note: this is still experimental.
        """
        pass
    def attrInfo(self, **kwargs):
        """
        attributeInfo
        
        Returns
        -------
        List[general.Attribute]
        """
        pass
    def attrSpec(*args, **kwargs):
        """
        Access to an attribute specifications of a node.  This does not require
        an instance:
        
            >>> nt.Transform.attrSpec('tx').isKeyable()
            True
        
        but it can use one if needed ( for example, for dynamically created attributes )
        
            >>> nt.Transform(u'persp').attrSpec('tx').isKeyable()
        
        Note: this is still experimental.
        """
        pass
    def attributeClass(self, attribute):
        """
        Returns the class (normal, dynamic, extension) of the specified attribute.
        
        Parameters:
        attribute : 'PyNode'
            the attribute to check
        
        
        Returns:
        'DependNode.MAttrClass'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.attributeClass`
        """
        pass
    def attributeCount(self):
        """
        Returns the number of attributes that this node has.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.attributeCount`
        """
        pass
    def canBeWritten(self):
        """
        Returns the do not write state of the node. Will be true if the node can be written/exported to scene files.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.canBeWritten`
        """
        pass
    def cast(self, swapNode, **kwargs):
        """
        nodeCast
        """
        pass
    def classification(self, **kwargs):
        """
        getClassification
        """
        pass
    def connectAttr(self, attr, destination, **kwargs):
        """
        Connect the attributes of two dependency nodes and return the names of the two
        connected attributes. The connected attributes must be be of compatible types.
        First argument is the source attribute, second one is the destination. Refer to
        dependency node documentation.
        
        Flags:
        - force : f                      (bool)          [create]
            Forces the connection.  If the destination is already connected, the old
            connection is broken and the new one made.
        
        - lock : l                       (bool)          [create]
            If the argument is true, the destination attribute is locked after making the
            connection. If the argument is false, the connection is unlocked before making
            the connection.
        
        - nextAvailable : na             (bool)          [create]
            If the destination multi-attribute has set the indexMatters to be false with
            this flag specified, a connection is made to the next available index. No index
            need be specified.
        
        - referenceDest : rd             (unicode)       [create]
            This flag is used for file io only. The flag indicates that the connection
            replaces a connection made in a referenced file, and the flag argument indicates
            the original destination from the referenced file. This flag is used so that if
            the reference file is modified, maya can still attempt to make the appropriate
            connections in the main scene to the referenced object.                  Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.connectAttr`
        """
        pass
    def deleteAttr(self, attr, *args, **kwargs):
        """
        This command is used to delete a dynamic attribute from a node or nodes. The
        attribute can be specified by using either the long or short name. Only one
        dynamic attribute can be deleted at a time. Static attributes cannot be deleted.
        Children of a compound attribute cannot be deleted. You must delete the complete
        compound attribute. This command has no edit capabilities. The only query
        ability is to list all the dynamic attributes of a node. In query mode, return
        type is based on queried flag.
        
        Flags:
        - attribute : at                 (unicode)       [create]
            Specify either the long or short name of the attribute.
        
        - name : n                       (unicode)       [create]
            The name of the node.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.deleteAttr`
        """
        pass
    def deletePreset(self, presetName): pass
    def destinations(self, **kwargs):
        """
        listConnections -source 0 -destination 1
        
        Returns
        -------
        List[general.PyNode]
        """
        pass
    def dgCallbacks(self, timerType, callbackName, value):
        """
        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.
        
        Parameters:
        timerType : 'DependNode.MdgTimerType'
            The timer we want to query, e.g. kTimerType_self for self time.
        
            values: 'type_self', 'type_inclusive', 'type_count', 'types'
        callbackName : List['list']
            Returns an array of callback names that were invoked for this node since the last timer reset.
        value : List['float']
            Returns an array of timing values. There is a one-to-one correspondence with the `callbackName' array.
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.dgCallbacks`
        """
        pass
    def dgTimer(self, timerMetric, timerType):
        """
        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.
        
        Parameters:
        timerMetric : 'DependNode.MdgTimerMetric'
            The timing metric we wish to query.
        
            values: 'metric_callback', 'metric_compute', 'metric_dirty', 'metric_draw', 'metric_fetch', 'metric_callbackViaAPI', 'metric_callbackNotViaAPI', 'metric_computeDuringCallback', 'metric_computeNotDuringCallback', 'metrics'
        timerType : 'DependNode.MdgTimerType'
            The timer type we wish to query.
        
            values: 'type_self', 'type_inclusive', 'type_count', 'types'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.dgTimer`
        """
        pass
    def dgTimerOff(self):
        """
        Indicates that this node should no longer collect DG timing data when DG timing is enabled. See dgTimerOn() and enableDGTiming() for more details.
        Derived from api method `maya.OpenMaya.MFnDependencyNode.dgTimerOff`
        """
        pass
    def dgTimerOn(self):
        """
        Indicates that this node should collect DG timing data whenever DG timing is enabled. See enableDGTiming() for more details.
        Derived from api method `maya.OpenMaya.MFnDependencyNode.dgTimerOn`
        """
        pass
    def dgTimerQueryState(self):
        """
        The function returns the current on/off state of the node's timer.
        
        Returns:
        'DependNode.MdgTimerState'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.dgTimerQueryState`
        """
        pass
    def 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().
        Derived from api method `maya.OpenMaya.MFnDependencyNode.dgTimerReset`
        """
        pass
    def disconnectAttr(self, attr, destination='None', **kwargs):
        """
        Disconnects two connected attributes. First argument is the source attribute,
        second is the destination.
        
        Flags:
        - nextAvailable : na             (bool)          [create]
            If the destination multi-attribute has set the indexMatters to be false, the
            command will disconnect the first matching connection.  No index needs to be
            specified.                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.disconnectAttr`
        """
        pass
    def duplicate(*args, **kwargs):
        """
        This command duplicates the given objects. If no objects are given, then the
        selected list is duplicated. The smart transform feature allows duplicate to
        transform newly duplicated objects based on previous transformations between
        duplications. Example: Duplicate an object and move it to a new location.
        Duplicate it again with the smart duplicate flag. It should have moved once
        again the distance you had previously moved it. Note: changing the selected list
        between smart duplications will cause the transform information to be deleted
        The upstream Nodes option forces duplication of all upstream nodes leading upto
        the selected objects.. Upstream nodes are defined as all nodes feeding into
        selected nodes. During traversal of Dependency graph, if another dagObject is
        encountered, then that node and all it's parent transforms are also duplicated.
        The inputConnections option forces the duplication of input connections to the
        nodes that are to be duplicated. This is very useful especially in cases where
        two nodes that are connected to each other are specified as nodes to be
        duplicated. In that situation, the connection between the nodes is also
        duplicated. See also:instance
        
        Modifications:
          - new option: addShape
                If addShape evaluates to True, then all arguments fed in must be shapes, and each will be duplicated and added under
                the existing parent transform, instead of duplicating the parent transform.
                The following arguments are incompatible with addShape, and will raise a ValueError if enabled along with addShape:
                    renameChildren (rc), instanceLeaf (ilf), parentOnly (po), smartTransform (st)
          - returns wrapped classes
          - returnRootsOnly is forced on for dag objects. This is because the duplicate command does not use full paths when returning
            the names of duplicated objects and will fail if the name is not unique.
        
        Returns
        -------
        List[nodetypes.DependNode]
        
        Flags:
        - inputConnections : ic          (bool)          [create]
            Input connections to the node to be duplicated, are also duplicated. This would
            result in a fan-out scenario as the nodes at the input side are not duplicated
            (unlike the -un option).
        
        - instanceLeaf : ilf             (bool)          [create]
            instead of duplicating leaf DAG nodes, instance them.
        
        - name : n                       (unicode)       [create]
            name to give duplicated object(s)
        
        - parentOnly : po                (bool)          [create]
            Duplicate only the specified DAG node and not any of its children.
        
        - renameChildren : rc            (bool)          [create]
            rename the child nodes of the hierarchy, to make them unique.
        
        - returnRootsOnly : rr           (bool)          [create]
            return only the root nodes of the new hierarchy. When used with upstreamNodes
            flag, the upstream nodes will be omitted in the result.  This flag controls only
            what is returned in the output string[], and it does NOT change the behaviour of
            the duplicate command.
        
        - smartTransform : st            (bool)          [create]
            remembers last transformation and applies it to duplicated object(s)
        
        - transformsOnly : to            (bool)          [create]
            Duplicate only transform nodes and not any shapes.
        
        - upstreamNodes : un             (bool)          [create]
            the upstream nodes leading upto the selected nodes (along with their
            connections) are also duplicated.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.duplicate`
        """
        pass
    def extractNum(self):
        """
        Return the trailing numbers of the node name.
        
        If no trailing numbers are found an error will be raised.
        
        >>> from pymel.core import *
        >>> SCENE.lambert1.extractNum()
        u'1'
        
        Returns
        -------
        unicode
        """
        pass
    def getAffectsAnimation(self):
        """
        Indicates whether or not this node is allowed to animate. See the setAffectsAnimation method for more information on what it means for a node to be allowed to animate.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.affectsAnimation`
        """
        pass
    def getAliasAttr(self, force):
        """
        Returns the node's alias attribute, which is a special attribute used to store information about the node's attribute aliases.
        
        Parameters:
        force : 'bool'
            To indicate whether the alias attr should be created.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.getAliasAttr`
        """
        pass
    def getAttr(self, attr, *args, **kwargs):
        """
        This command returns the value of the named object's attribute. UI units are
        used where applicable. Currently, the types of attributes that can be displayed
        are: numeric attributesstring attributesmatrix attributesnumeric compound
        attributes (whose children are all numeric)vector array attributesdouble array
        attributesint32 array attributespoint array attributesdata component list
        attributesOther data types cannot be retrieved. No result is returned if the
        attribute contains no data.
        
        Flags:
        - asString : asString            (bool)          [create]
            This flag is only valid for enum attributes. It allows you to get the attribute
            values as strings instead of integer values. Note that the returned string value
            is dependent on the UI language Maya is running in (about -uiLanguage).
        
        - caching : ca                   (bool)          [create]
            Returns whether the attribute is set to be cached internally
        
        - channelBox : cb                (bool)          [create]
            Returns whether the attribute is set to show in the channelBox. Keyable
            attributes also show in the channel box.
        
        - expandEnvironmentVariables : x (bool)          [create]
            Expand any environment variable and (tilde characters on UNIX) found in string
            attributes which are returned.
        
        - keyable : k                    (bool)          [create]
            Returns the keyable state of the attribute.
        
        - lock : l                       (bool)          [create]
            Returns the lock state of the attribute.
        
        - multiIndices : mi              (bool)          [create]
            If the attribute is a multi, this will return a list containing all of the valid
            indices for the attribute.
        
        - settable : se                  (bool)          [create]
            Returns 1 if this attribute is currently settable by setAttr, 0 otherwise. An
            attribute is settable if it's not locked and either not connected, or has only
            keyframed animation.
        
        - silent : sl                    (bool)          [create]
            When evaluating an attribute that is not a numeric or string value, suppress the
            error message saying that the data cannot be displayed. The attribute will be
            evaluated even though its data cannot be displayed. This flag does not suppress
            all error messages, only those that are benign.
        
        - size : s                       (bool)          [create]
            Returns the size of a multi-attribute array.  Returns 1 if non-multi.
        
        - time : t                       (time)          [create]
            Evaluate the attribute at the given time instead of the current time.
        
        - type : typ                     (bool)          [create]
            Returns the type of data currently in the attribute. Attributes of simple types
            such as strings and numerics always contain data, but attributes of complex
            types (arrays, meshes, etc) may contain no data if none has ever been assigned
            to them. When this happens the command will return with no result: not an empty
            string, but no result at all. Attempting to directly compare this non-result to
            another value or use it in an expression will result in an error, but you can
            assign it to a variable in which case the variable will be set to the default
            value for its type (e.g. an empty string for a string variable, zero for an
            integer variable, an empty array for an array variable). So to be safe when
            using this flag, always assign its result to a string variable, never try to use
            it directly.                   Flag can have multiple arguments, passed either
            as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.getAttr`
        """
        pass
    def getIcon(self):
        """
        Returns the custom icon filename associated with the node. The icon can be assigned using setIcon().
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.icon`
        """
        pass
    def getName(self):
        """
        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.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.name`
        """
        pass
    def hasAttr(pyObj, attr, checkShape='True'):
        """
        Convenience function for determining if an object has an attribute.
        
        Parameters
        ----------
        pyObj : PyNode
        attr : Union[unicode, Attribute, AttributeSpec]
        checkShape : bool
            If enabled, the shape node of a transform will also be
            checked for the attribute.
        
        Returns
        -------
        bool
        """
        pass
    def hasAttribute(self, attrName):
        """
        Returns true if the node already has an attribute with the given name.
        
        Parameters:
        attrName : 'unicode'
            Name of attribute to be checked.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.hasAttribute`
        """
        pass
    def hasUniqueName(self):
        """
        Indicates whether or not this node's name is unique within the scene.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.hasUniqueName`
        
        Aliases: hasUniqueName, isUniquelyNamed
        """
        pass
    def inputs(self, **kwargs):
        """
        listConnections -source 1 -destination 0
        
        Returns
        -------
        List[general.PyNode]
        """
        pass
    def isDefaultNode(self):
        """
        Returns true if the node is a default node.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isDefaultNode`
        """
        pass
    def isFlagSet(self, flag):
        """
        Retrieves the current state of the specified flag for a node.
        
        Parameters:
        flag : 'int'
            number of the flag to retrieve.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isFlagSet`
        """
        pass
    def isFromReferencedFile(self):
        """
        Indicates whether or not this node came from a referenced file. If it did, the node will be marked as read-only in the scene and changes to the node's attributes will be saved in the main scene file, not the referenced file from which the node came.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isFromReferencedFile`
        
        Aliases: isFromReferencedFile, isReadOnly, isReferenced
        """
        pass
    def isLocked(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isLocked`
        """
        pass
    def isNewAttribute(self, attr):
        """
        Indicates whether or not the specified attribute was added to this node within the current scene.
        
        Parameters:
        attr : 'PyNode'
            Attribute to check.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isNewAttribute`
        """
        pass
    def isReadOnly(self):
        """
        Indicates whether or not this node came from a referenced file. If it did, the node will be marked as read-only in the scene and changes to the node's attributes will be saved in the main scene file, not the referenced file from which the node came.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isFromReferencedFile`
        
        Aliases: isFromReferencedFile, isReadOnly, isReferenced
        """
        pass
    def isReferenced(self):
        """
        Indicates whether or not this node came from a referenced file. If it did, the node will be marked as read-only in the scene and changes to the node's attributes will be saved in the main scene file, not the referenced file from which the node came.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isFromReferencedFile`
        
        Aliases: isFromReferencedFile, isReadOnly, isReferenced
        """
        pass
    def isShared(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isShared`
        """
        pass
    def isTrackingEdits(self):
        """
        Returns whether or not edits on the given node are being tracked by the generalized edit system.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.isTrackingEdits`
        """
        pass
    def isUniquelyNamed(self):
        """
        Indicates whether or not this node's name is unique within the scene.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.hasUniqueName`
        
        Aliases: hasUniqueName, isUniquelyNamed
        """
        pass
    def listAliases(self):
        """
        aliasAttr
        
        Modifications:
          - returns an empty list when the result is None
          - when queried, returns a list of (alias, `Attribute`) pairs.
        
        Returns
        -------
        List[Tuple[str, general.Attribute]]
        """
        pass
    def listAnimatable(*args, **kwargs):
        """
        This command list the animatable attributes of a node.  Command flags allow
        filtering by the current manipulator, or node type.
        
        Modifications:
            - returns an empty list when the result is None
            - returns wrapped classes
        
        Flags:
        - active : act                   (bool)          [create]
            This flag is obsolete and no longer supported.
        
        - manip : m                      (bool)          [create]
            Return only those attributes affected by the current manip. If there is no manip
            active and any other flags are specified, output is the same as if the
            -manipflag were not present.
        
        - manipHandle : mh               (bool)          [create]
            Return only those attributes affected by the current manip handle. If there is
            no manip handle active and any other flags are specified, output is the same as
            if the -manipHandleflag were not present.
        
        - shape : s                      (bool)          [create]
            This flag is obsolete and no longer supported.
        
        - type : typ                     (bool)          [create]
            Instead of returning attributes, Return the types of nodes that are currently
            animatable.                  Flag can have multiple arguments, passed either as
            a tuple or a list.
        
        
        Derived from mel command `maya.cmds.listAnimatable`
        """
        pass
    def listAttr(self, **kwargs):
        """
        listAttr
        
        Modifications:
          - returns an empty list when the result is None
          - added 'alias' keyword to list attributes that have aliases
          - added 'topLevel' keyword to only return attributes that are not
            compound children; may not be used in combination with
            'descendants'
          - added 'descendants' keyword to return all top-level attributes
            and all their descendants; note that the standard call may return
            some attributes that 'descendants' will not, if there are compound
            multi attributes with no existing indices; ie, the standard call
            might return "node.parentAttr[-1].childAttr", but the 'descendants'
            version would only return childAttr if an index exists for
            parentAttr, ie "node.parentAttr[0].childAttr"; may not be used in
            combination with 'topLevel'
        
        Returns
        -------
        List[general.Attribute]
        """
        pass
    def listPresets(self): pass
    def loadPreset(self, presetName): pass
    def lock(self, **kwargs):
        """
        lockNode -lock 1
        """
        pass
    def longName(self, **kwargs):
        """
        This produces the same results as `DependNode.name` and is included to
        simplify looping over lists of nodes that include both Dag and Depend
        nodes.
        
        Returns
        -------
        unicode
        """
        pass
    def name(self, update='True', stripNamespace='False', levels='0', long='False', stripUnderWorld='False'):
        """
        The name of the node
        
        Returns
        -------
        unicode
        
        Parameters
        ----------
        update : bool
            if True, will always query to underlying maya object to get it's
            current name (and will therefore detect renames, re-parenting, etc);
            if False, it will use a cached value if available (which is slightly
            faster, but may be out of date)
        stripNamespace : bool
            if True, all nodes will have their namespaces stipped off of them
            (or a certain number of them, if levels is also used)
        levels : int
            if stripNamespace is True, then this number will determine the how
            many namespaces will be removed; if 0 (the default), then all
            leading namespaces will be removed; otherwise, this value gives the
            number of left-most levels to strip
        long : bool
            ignored; included simply to unify the interface between DependNode
            and DagNode, to make it easier to loop over lists of them
        stripUnderWorld : bool
            ignored; included simply to unify the interface between DependNode
            and DagNode, to make it easier to loop over lists of them
        
        
        Examples
        --------
        >>> import pymel.core as pm
        >>> pm.newFile(f=1)
        ''
        >>> node = pm.createNode('blinn')
        
        >>> pm.namespace(add='foo')
        u'foo'
        >>> pm.namespace(add='bar', parent='foo')
        u'foo:bar'
        >>> pm.namespace(add='stuff', parent='foo:bar')
        u'foo:bar:stuff'
        
        >>> node.rename(':foo:bar:stuff:blinn1')
        nt.Blinn(u'foo:bar:stuff:blinn1')
        
        >>> node.name()
        u'foo:bar:stuff:blinn1'
        >>> node.name(stripNamespace=True)
        u'blinn1'
        >>> node.name(stripNamespace=True, levels=1)
        u'bar:stuff:blinn1'
        >>> node.name(stripNamespace=True, levels=2)
        u'stuff:blinn1'
        """
        pass
    def namespace(self, root='False'):
        """
        Returns the namespace of the object with trailing colon included.
        
        See `DependNode.parentNamespace` for a variant which does not include
        the trailing colon.
        
        Parameters
        ----------
        root : bool
            By default, if the object is in the root namespace, an empty string
            is returned; if root is True, ':' is returned in this case.
        
        Returns
        -------
        unicode
        """
        pass
    def nextName(self):
        """
        Increment the trailing number of the object by 1
        
        Raises an error if the name has no trailing number.
        
        >>> from pymel.core import *
        >>> SCENE.lambert1.nextName()
        DependNodeName(u'lambert2')
        
        Returns
        -------
        unicode
        """
        pass
    def nextUniqueName(self):
        """
        Increment the trailing number of the object until a unique name is
        found.
        
        If there is no trailing number, appends '1' to the name.
        
        Returns
        -------
        unicode
        """
        pass
    def node(self):
        """
        for compatibility with Attribute class
        
        Returns
        -------
        DependNode
        """
        pass
    def nodeName(self, **kwargs):
        """
        This produces the same results as `DependNode.name` and is included to
        simplify looping over lists of nodes that include both Dag and Depend
        nodes.
        
        Returns
        -------
        unicode
        """
        pass
    def outputs(self, **kwargs):
        """
        listConnections -source 0 -destination 1
        
        Returns
        -------
        List[general.PyNode]
        """
        pass
    def parentNamespace(self):
        """
        Returns the name of the namespace in which this node resides. Namespaces are often used when importing files to prevent name collisions.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.parentNamespace`
        """
        pass
    def pluginName(self):
        """
        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.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.pluginName`
        """
        pass
    def prevName(self):
        """
        Decrement the trailing number of the object by 1
        
        Raises an error if the name has no trailing number.
        
        Returns
        -------
        unicode
        """
        pass
    def referenceFile(self):
        """
        referenceQuery -file
        Return the reference file to which this object belongs.
        None if object is not referenced
        
        Returns
        -------
        Optional[_FileReference]
        """
        pass
    def removeAttribute(self, attr, *args, **kwargs):
        """
        This command is used to delete a dynamic attribute from a node or nodes. The
        attribute can be specified by using either the long or short name. Only one
        dynamic attribute can be deleted at a time. Static attributes cannot be deleted.
        Children of a compound attribute cannot be deleted. You must delete the complete
        compound attribute. This command has no edit capabilities. The only query
        ability is to list all the dynamic attributes of a node. In query mode, return
        type is based on queried flag.
        
        Flags:
        - attribute : at                 (unicode)       [create]
            Specify either the long or short name of the attribute.
        
        - name : n                       (unicode)       [create]
            The name of the node.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.deleteAttr`
        """
        pass
    def rename(self, name, **kwargs):
        """
        Returns
        -------
        DependNode
        """
        pass
    def savePreset(self, presetName, custom='None', attributes='[]'): pass
    def setAffectsAnimation(self):
        """
        Define a node can affect animation. Normally this is done automatically through the evaluation graph creation process but if you know from the start that your node will definitely participate in animation then you can mark it as such at any point.
        Derived from api method `maya.OpenMaya.MFnDependencyNode.setAffectsAnimation`
        """
        pass
    def setAttr(self, attr, *args, **kwargs):
        """
        Sets the value of a dependency node attribute.  No value for the the attribute
        is needed when the -l/-k/-s flags are used. The -type flag is only required when
        setting a non-numeric attribute. The following chart outlines the syntax of
        setAttr for non-numeric data types: TYPEbelow means any number of values of type
        TYPE, separated by a space[TYPE]means that the value of type TYPEis
        optionalA|Bmeans that either of Aor Bmay appearIn order to run its examples,
        first execute these commands to create the sample attribute types:sphere -n
        node; addAttr -ln short2Attr -at short2; addAttr -ln short2a -p short2Attr -at
        short; addAttr -ln short2b -p short2Attr -at short; addAttr -ln short3Attr -at
        short3; addAttr -ln short3a -p short3Attr -at short; addAttr -ln short3b -p
        short3Attr -at short; addAttr -ln short3c -p short3Attr -at short; addAttr -ln
        long2Attr -at long2; addAttr -ln long2a -p long2Attr -at long; addAttr -ln
        long2b -p long2Attr -at long; addAttr -ln long3Attr -at long3; addAttr -ln
        long3a -p long3Attr -at long; addAttr -ln long3b -p long3Attr -at long; addAttr
        -ln long3c -p long3Attr -at long; addAttr -ln float2Attr -at float2; addAttr -ln
        float2a -p float2Attr -at float; addAttr -ln float2b -p float2Attr -at float;
        addAttr -ln float3Attr -at float3; addAttr -ln float3a -p float3Attr -at float;
        addAttr -ln float3b -p float3Attr -at float; addAttr -ln float3c -p float3Attr
        -at float; addAttr -ln double2Attr -at double2; addAttr -ln double2a -p
        double2Attr -at double; addAttr -ln double2b -p double2Attr -at double; addAttr
        -ln double3Attr -at double3; addAttr -ln double3a -p double3Attr -at double;
        addAttr -ln double3b -p double3Attr -at double; addAttr -ln double3c -p
        double3Attr -at double; addAttr -ln int32ArrayAttr -dt Int32Array; addAttr -ln
        doubleArrayAttr -dt doubleArray; addAttr -ln pointArrayAttr -dt pointArray;
        addAttr -ln vectorArrayAttr -dt vectorArray; addAttr -ln stringArrayAttr -dt
        stringArray; addAttr -ln stringAttr -dt string; addAttr -ln matrixAttr -dt
        matrix; addAttr -ln sphereAttr -dt sphere; addAttr -ln coneAttr -dt cone;
        addAttr -ln meshAttr -dt mesh; addAttr -ln latticeAttr -dt lattice; addAttr -ln
        spectrumRGBAttr -dt spectrumRGB; addAttr -ln reflectanceRGBAttr -dt
        reflectanceRGB; addAttr -ln componentListAttr -dt componentList; addAttr -ln
        attrAliasAttr -dt attributeAlias; addAttr -ln curveAttr -dt nurbsCurve; addAttr
        -ln surfaceAttr -dt nurbsSurface; addAttr -ln trimFaceAttr -dt nurbsTrimface;
        addAttr -ln polyFaceAttr -dt polyFaces; -type short2Array of two short
        integersValue Syntaxshort shortValue Meaningvalue1 value2Mel ExamplesetAttr
        node.short2Attr -type short2 1 2;Python
        Examplecmds.setAttr('node.short2Attr',1,2,type='short2')-type short3Array of
        three short integersValue Syntaxshort short shortValue Meaningvalue1 value2
        value3Mel ExamplesetAttr node.short3Attr -type short3 1 2 3;Python
        Examplecmds.setAttr('node.short3Attr',1,2,3,type='short3')-type long2Array of
        two long integersValue Syntaxlong longValue Meaningvalue1 value2Mel
        ExamplesetAttr node.long2Attr -type long2 1000000 2000000;Python
        Examplecmds.setAttr('node.long2Attr',1000000,2000000,type='long2')-type
        long3Array of three long integersValue Syntaxlong long longValue Meaningvalue1
        value2 value3Mel ExamplesetAttr node.long3Attr -type long3 1000000 2000000
        3000000;Python
        Examplecmds.setAttr('node.long3Attr',1000000,2000000,3000000,type='long3')-type
        Int32ArrayVariable length array of long integersValue SyntaxValue MeaningMel
        ExamplesetAttr node.int32ArrayAttr -type Int32Array 2 12 75;Python
        Examplecmds.setAttr('node.int32ArrayAttr',[2,12,75],type='Int32Array')-type
        float2Array of two floatsValue Syntaxfloat floatValue Meaningvalue1 value2Mel
        ExamplesetAttr node.float2Attr -type float2 1.1 2.2;Python
        Examplecmds.setAttr('node.float2Attr',1.1,2.2,type='float2')-type float3Array of
        three floatsValue Syntaxfloat float floatValue Meaningvalue1 value2 value3Mel
        ExamplesetAttr node.float3Attr -type float3 1.1 2.2 3.3;Python
        Examplecmds.setAttr('node.float3Attr',1.1,2.2,3.3,type='float3')-type
        double2Array of two doublesValue Syntaxdouble doubleValue Meaningvalue1
        value2Mel ExamplesetAttr node.double2Attr -type double2 1.1 2.2;Python
        Examplecmds.setAttr('node.double2Attr',1.1,2.2,type='double2')-type double3Array
        of three doublesValue Syntaxdouble double doubleValue Meaningvalue1 value2
        value3Mel ExamplesetAttr node.double3Attr -type double3 1.1 2.2 3.3;Python
        Examplecmds.setAttr('node.double3Attr',1.1,2.2,3.3,type='double3')-type
        doubleArrayVariable length array of doublesValue SyntaxValue MeaningMel
        ExamplesetAttr node.doubleArrayAttr -type doubleArray 2 3.14159 2.782;Python
        Examplecmds.setAttr( node.doubleArrayAttr, (2, 3.14159, 2.782,),
        type=doubleArray)-type matrix4x4 matrix of doublesValue Syntaxdouble double
        double doubledouble double double doubledouble double double doubledouble double
        double doubleValue Meaningrow1col1 row1col2 row1col3 row1col4row2col1 row2col2
        row2col3 row2col4row3col1 row3col2 row3col3 row3col4row4col1 row4col2 row4col3
        row4col4Alternate Syntaxstring double double doubledouble double
        doubleintegerdouble double doubledouble double doubledouble double doubledouble
        double doubledouble double doubledouble double doubledouble double double
        doubledouble double double doubledouble double doublebooleanAlternate
        MeaningxformscaleX scaleY scaleZrotateX rotateY rotateZrotationOrder (0=XYZ,
        1=YZX, 2=ZXY, 3=XZY, 4=YXZ, 5=ZYX)translateX translateY translateZshearXY
        shearXZ shearYZscalePivotX scalePivotY scalePivotZscaleTranslationX
        scaleTranslationY scaleTranslationZrotatePivotX rotatePivotY
        rotatePivotZrotateTranslationX rotateTranslationY
        rotateTranslationZrotateOrientW rotateOrientX rotateOrientY
        rotateOrientZjointOrientW jointOrientX jointOrientY
        jointOrientZinverseParentScaleX inverseParentScaleY
        inverseParentScaleZcompensateForParentScale Mel ExamplesetAttr node.matrixAttr
        -type matrix1 0 0 0 0 1 0 0 0 0 1 0 2 3 4 1;setAttr node.matrixAttr -type
        matrixxform1 1 1 0 0 0 0 2 3 4 0 0 00 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1
        0 false;Python Examplecmds.setAttr('node.matrixAttr',(1,0,0,0,0,1,0,0,0,0,1,0,2,
        3,4,1),type='matrix')cmds.setAttr('node.matrixAttr','xform',(1,1,1),(0,0,0),0,(2
        ,3,4),(0,0,0),(0,0,0),(0,0,0),(0,0,0),(0,1,1),(0,0,1,0),(1,0,1,0),(1,2,3),False,
        type=matrix)-type pointArrayVariable length array of pointsValue SyntaxValue
        MeaningMel ExamplesetAttr node.pointArrayAttr -type pointArray 2 1 1 1 1 2 2 2
        1;Python Examplecmds.setAttr('node.pointArrayAttr',2,(1,1,1,1),(2,2,2,1),type='p
        ointArray')-type vectorArrayVariable length array of vectorsValue SyntaxValue
        MeaningMel ExamplesetAttr node.vectorArrayAttr -type vectorArray 2 1 1 1 2 2
        2;Python Examplecmds.setAttr('node.vectorArrayAttr',2,(1,1,1),(2,2,2),type='vect
        orArray')-type stringCharacter stringValue SyntaxstringValue
        MeaningcharacterStringValueMel ExamplesetAttr node.stringAttr -type
        stringblarg;Python Examplecmds.setAttr('node.stringAttr',blarg,type=string)-type
        stringArrayVariable length array of stringsValue SyntaxValue MeaningMel
        ExamplesetAttr node.stringArrayAttr -type stringArray 3 abc;Python
        Examplecmds.setAttr('node.stringArrayAttr',3,a,b,c,type='stringArray')-type
        sphereSphere dataValue SyntaxdoubleValue MeaningsphereRadiusExamplesetAttr
        node.sphereAttr -type sphere 5.0;-type coneCone dataValue Syntaxdouble
        doubleValue MeaningconeAngle coneCapMel ExamplesetAttr node.coneAttr -type cone
        45.0 5.0;Python Examplecmds.setAttr('node.coneAttr',45.0,5.0,type='cone')-type
        reflectanceRGBReflectance dataValue Syntaxdouble double doubleValue
        MeaningredReflect greenReflect blueReflectMel ExamplesetAttr
        node.reflectanceRGBAttr -type reflectanceRGB 0.5 0.5 0.1;Python Examplecmds.setA
        ttr('node.reflectanceRGBAttr',0.5,0.5,0.1,type='reflectanceRGB')-type
        spectrumRGBSpectrum dataValue Syntaxdouble double doubleValue MeaningredSpectrum
        greenSpectrum blueSpectrumMel ExamplesetAttr node.spectrumRGBAttr -type
        spectrumRGB 0.5 0.5 0.1;Python
        Examplecmds.setAttr('node.spectrumRGBAttr',0.5,0.5,0.1,type='spectrumRGB')-type
        componentListVariable length array of componentsValue SyntaxValue MeaningMel
        ExamplesetAttr node.componentListAttr -type componentList 3 cv[1] cv[12]
        cv[3];Python Examplecmds.setAttr('node.componentListAttr',3,'cv[1]','cv[12]','cv
        [3]',type='componentList')-type attributeAliasString alias dataValue
        Syntaxstring stringValue MeaningnewAlias currentNameMel ExamplesetAttr
        node.attrAliasAttr -type attributeAliasGoUp, translateY, GoLeft,
        translateX;Python Examplecmds.setAttr('node.attrAliasAttr',(GoUp,
        translateY,GoLeft, translateX),type='attributeAlias')-type nurbsCurveNURBS curve
        dataValue SyntaxValue MeaningMel Example// degree is the degree of the
        curve(range 1-7)// spans is the number of spans // form is open (0), closed (1),
        periodic (2)// dimension is 2 or 3, depending on the dimension of the curve//
        isRational is true if the curve CVs contain a rational component // knotCount is
        the size of the knot list//  knotValue is a single entry in the knot list//
        cvCount is the number of CVs in the curve//  xCVValue,yCVValue,[zCVValue]
        [wCVValue] is a single CV.//  zCVValue is only present when dimension is 3.//
        wCVValue is only present when isRational is true.//setAttr node.curveAttr -type
        nurbsCurve 3 1 0 no 36 0 0 0 1 1 14 -2 3 0 -2 1 0 -2 -1 0 -2 -3 0;-type
        nurbsSurfaceNURBS surface dataValue Syntaxint int int int bool Value
        MeaninguDegree vDegree uForm vForm isRationalTRIM|NOTRIMExample// uDegree is
        degree of the surface in U direction (range 1-7)// vDegree is degree of the
        surface in V direction (range 1-7)// uForm is open (0), closed (1), periodic (2)
        in U direction// vForm is open (0), closed (1), periodic (2) in V direction//
        isRational is true if the surface CVs contain a rational component// uKnotCount
        is the size of the U knot list//  uKnotValue is a single entry in the U knot
        list// vKnotCount is the size of the V knot list//  vKnotValue is a single entry
        in the V knot list// If TRIMis specified then additional trim information is
        expected// If NOTRIMis specified then the surface is not trimmed// cvCount is
        the number of CVs in the surface//  xCVValue,yCVValue,zCVValue [wCVValue]is a
        single CV.//  zCVValue is only present when dimension is 3.//  wCVValue is only
        present when isRational is true//setAttr node.surfaceAttr -type nurbsSurface 3 3
        0 0 no 6 0 0 0 1 1 16 0 0 0 1 1 116 -2 3 0 -2 1 0 -2 -1 0 -2 -3 0-1 3 0 -1 1 0
        -1 -1 0 -1 -3 01 3 0 1 1 0 1 -1 0 1 -3 03 3 0 3 1 0 3 -1 0 3 -3 0;-type
        nurbsTrimfaceNURBS trim face dataValue SyntaxValue MeaningExample// flipNormal
        if true turns the surface inside out// boundaryCount: number of boundaries//
        boundaryType: // tedgeCountOnBoundary    : number of edges in a boundary//
        splineCountOnEdge    : number of splines in an edge in// edgeTolerance        :
        tolerance used to build the 3d edge// isEdgeReversed        : if true, the edge
        is backwards// geometricContinuity    : if true, the edge is tangent
        continuous// splineCountOnPedge    : number of splines in a 2d edge// isMonotone
        : if true, curvature is monotone// pedgeTolerance        : tolerance for the 2d
        edge//-type polyFacesPolygon face dataValue SyntaxfhmfmhmumcValue
        MeaningfhmfmhmumcExample// This data type (polyFace) is meant to be used in file
        I/O// after setAttrs have been written out for vertex position// arrays, edge
        connectivity arrays (with corresponding start// and end vertex descriptions),
        texture coordinate arrays and// color arrays.  The reason is that this data type
        references// all of its data through ids created by the former types.////
        fspecifies the ids of the edges making up a face -//     negative value if the
        edge is reversed in the face// hspecifies the ids of the edges making up a hole
        -//     negative value if the edge is reversed in the face// mfspecifies the ids
        of texture coordinates (uvs) for a face.//     This data type is obsolete as of
        version 3.0. It is replaced by mu.// mhspecifies the ids of texture coordinates
        (uvs) for a hole//     This data type is obsolete as of version 3.0. It is
        replaced by mu.// muThe  first argument refers to the uv set. This is a zero-
        based//     integer number. The second argument refers to the number of vertices
        (n)//     on the face which have valid uv values. The last n values are the uv//
        ids of the texture coordinates (uvs) for the face. These indices//     are what
        used to be represented by the mfand mhspecification.//     There may be more
        than one muspecification, one for each unique uv set.// mcspecifies the color
        index values for a face. The first argument//     is color index. The second
        argument is the number of color ids to follow.//     Rest of the arguments are
        color ids for the face.//setAttr node.polyFaceAttr -type polyFaces f3 1 2 3 mc0
        4 0 1 2 3;-type meshPolygonal meshValue SyntaxValue
        Meaningvvn[vtesmooth|hard]Example// vspecifies the vertices of the polygonal
        mesh// vnspecifies the normal of each vertex// vtis optional and specifies a U,V
        texture coordinate for each vertex// especifies the edge connectivity
        information between vertices//setAttr node.meshAttr -type mesh v3 0 0 0 0 1 0 0
        0 1vn3 1 0 0 1 0 0 1 0 0vt3 0 0 0 1 1 0e3 0 1 hard1 2 hard2 0 hard;-type
        latticeLattice dataValue SyntaxValue MeaningsDivisionCount tDivisionCount
        uDivisionCountExample// sDivisionCount is the horizontal lattice division
        count// tDivisionCount is the vertical lattice division count// uDivisionCount
        is the depth lattice division count// pointCount is the total number of lattice
        points// pointX,pointY,pointZ is one lattice point.  The list is//   specified
        varying first in S, then in T, last in U so the//   first two entries are
        (S=0,T=0,U=0) (s=1,T=0,U=0)//setAttr node.latticeAttr -type lattice 2 5 2 20-2
        -2 -2 2 -2 -2 -2 -1 -2 2 -1 -2 -2 0 -22 0 -2 -2 1 -2 2 1 -2 -2 2 -2 2 2 -2-2 -2
        2 2 -2 2 -2 -1 2 2 -1 2 -2 0 22 0 2 -2 1 2 2 1 2 -2 2 2 2 2 2;In query mode,
        return type is based on queried flag.
        
        Flags:
        - alteredValue : av              (bool)          [create]
            The value is only the current value, which may change in the next evalution (if
            the attribute has an incoming connection). This flag is only used during file
            I/O, so that attributes with incoming connections do not have their data
            overwritten during the first evaluation after a file is opened.
        
        - caching : ca                   (bool)          [create]
            Sets the attribute's internal caching on or off. Not all attributes can be
            defined as caching. Only those attributes that are not defined by default to be
            cached can be made caching.  As well, multi attribute elements cannot be made
            caching. Caching also affects child attributes for compound attributes.
        
        - capacityHint : ch              (int)           [create]
            Used to provide a memory allocation hint to attributes where the -size flag
            cannot provide enough information. This flag is optional and is primarily
            intended to be used during file I/O. Only certain attributes make use of this
            flag, and the interpretation of the flag value varies per attribute. This flag
            is currently used by (node.attribute): mesh.face - hints the total number of
            elements in the face edge lists
        
        - channelBox : cb                (bool)          [create]
            Sets the attribute's display in the channelBox on or off. Keyable attributes are
            always display in the channelBox regardless of the channelBox settting.
        
        - clamp : c                      (bool)          [create]
            For numeric attributes, if the value is outside the range of the attribute,
            clamp it to the min or max instead of failing
        
        - keyable : k                    (bool)          [create]
            Sets the attribute's keyable state on or off.
        
        - lock : l                       (bool)          [create]
            Sets the attribute's lock state on or off.
        
        - size : s                       (int)           [create]
            Defines the size of a multi-attribute array. This is only a hint, used to help
            allocate memory as efficiently as possible.
        
        - type : typ                     (unicode)       [create]
            Identifies the type of data.  If the -type flag is not present, a numeric type
            is assumed.                  Flag can have multiple arguments, passed either as
            a tuple or a list.
        
        
        Derived from mel command `maya.cmds.setAttr`
        """
        pass
    def setDoNotWrite(self, flag):
        """
        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.
        
        Parameters:
        flag : 'bool'
            True if the node should not be saved.
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.setDoNotWrite`
        """
        pass
    def setDynamicAttr(self, attr, *args, **kwargs):
        """
        Sets the value of a dependency node attribute.  No value for the the attribute
        is needed when the -l/-k/-s flags are used. The -type flag is only required when
        setting a non-numeric attribute. The following chart outlines the syntax of
        setAttr for non-numeric data types: TYPEbelow means any number of values of type
        TYPE, separated by a space[TYPE]means that the value of type TYPEis
        optionalA|Bmeans that either of Aor Bmay appearIn order to run its examples,
        first execute these commands to create the sample attribute types:sphere -n
        node; addAttr -ln short2Attr -at short2; addAttr -ln short2a -p short2Attr -at
        short; addAttr -ln short2b -p short2Attr -at short; addAttr -ln short3Attr -at
        short3; addAttr -ln short3a -p short3Attr -at short; addAttr -ln short3b -p
        short3Attr -at short; addAttr -ln short3c -p short3Attr -at short; addAttr -ln
        long2Attr -at long2; addAttr -ln long2a -p long2Attr -at long; addAttr -ln
        long2b -p long2Attr -at long; addAttr -ln long3Attr -at long3; addAttr -ln
        long3a -p long3Attr -at long; addAttr -ln long3b -p long3Attr -at long; addAttr
        -ln long3c -p long3Attr -at long; addAttr -ln float2Attr -at float2; addAttr -ln
        float2a -p float2Attr -at float; addAttr -ln float2b -p float2Attr -at float;
        addAttr -ln float3Attr -at float3; addAttr -ln float3a -p float3Attr -at float;
        addAttr -ln float3b -p float3Attr -at float; addAttr -ln float3c -p float3Attr
        -at float; addAttr -ln double2Attr -at double2; addAttr -ln double2a -p
        double2Attr -at double; addAttr -ln double2b -p double2Attr -at double; addAttr
        -ln double3Attr -at double3; addAttr -ln double3a -p double3Attr -at double;
        addAttr -ln double3b -p double3Attr -at double; addAttr -ln double3c -p
        double3Attr -at double; addAttr -ln int32ArrayAttr -dt Int32Array; addAttr -ln
        doubleArrayAttr -dt doubleArray; addAttr -ln pointArrayAttr -dt pointArray;
        addAttr -ln vectorArrayAttr -dt vectorArray; addAttr -ln stringArrayAttr -dt
        stringArray; addAttr -ln stringAttr -dt string; addAttr -ln matrixAttr -dt
        matrix; addAttr -ln sphereAttr -dt sphere; addAttr -ln coneAttr -dt cone;
        addAttr -ln meshAttr -dt mesh; addAttr -ln latticeAttr -dt lattice; addAttr -ln
        spectrumRGBAttr -dt spectrumRGB; addAttr -ln reflectanceRGBAttr -dt
        reflectanceRGB; addAttr -ln componentListAttr -dt componentList; addAttr -ln
        attrAliasAttr -dt attributeAlias; addAttr -ln curveAttr -dt nurbsCurve; addAttr
        -ln surfaceAttr -dt nurbsSurface; addAttr -ln trimFaceAttr -dt nurbsTrimface;
        addAttr -ln polyFaceAttr -dt polyFaces; -type short2Array of two short
        integersValue Syntaxshort shortValue Meaningvalue1 value2Mel ExamplesetAttr
        node.short2Attr -type short2 1 2;Python
        Examplecmds.setAttr('node.short2Attr',1,2,type='short2')-type short3Array of
        three short integersValue Syntaxshort short shortValue Meaningvalue1 value2
        value3Mel ExamplesetAttr node.short3Attr -type short3 1 2 3;Python
        Examplecmds.setAttr('node.short3Attr',1,2,3,type='short3')-type long2Array of
        two long integersValue Syntaxlong longValue Meaningvalue1 value2Mel
        ExamplesetAttr node.long2Attr -type long2 1000000 2000000;Python
        Examplecmds.setAttr('node.long2Attr',1000000,2000000,type='long2')-type
        long3Array of three long integersValue Syntaxlong long longValue Meaningvalue1
        value2 value3Mel ExamplesetAttr node.long3Attr -type long3 1000000 2000000
        3000000;Python
        Examplecmds.setAttr('node.long3Attr',1000000,2000000,3000000,type='long3')-type
        Int32ArrayVariable length array of long integersValue SyntaxValue MeaningMel
        ExamplesetAttr node.int32ArrayAttr -type Int32Array 2 12 75;Python
        Examplecmds.setAttr('node.int32ArrayAttr',[2,12,75],type='Int32Array')-type
        float2Array of two floatsValue Syntaxfloat floatValue Meaningvalue1 value2Mel
        ExamplesetAttr node.float2Attr -type float2 1.1 2.2;Python
        Examplecmds.setAttr('node.float2Attr',1.1,2.2,type='float2')-type float3Array of
        three floatsValue Syntaxfloat float floatValue Meaningvalue1 value2 value3Mel
        ExamplesetAttr node.float3Attr -type float3 1.1 2.2 3.3;Python
        Examplecmds.setAttr('node.float3Attr',1.1,2.2,3.3,type='float3')-type
        double2Array of two doublesValue Syntaxdouble doubleValue Meaningvalue1
        value2Mel ExamplesetAttr node.double2Attr -type double2 1.1 2.2;Python
        Examplecmds.setAttr('node.double2Attr',1.1,2.2,type='double2')-type double3Array
        of three doublesValue Syntaxdouble double doubleValue Meaningvalue1 value2
        value3Mel ExamplesetAttr node.double3Attr -type double3 1.1 2.2 3.3;Python
        Examplecmds.setAttr('node.double3Attr',1.1,2.2,3.3,type='double3')-type
        doubleArrayVariable length array of doublesValue SyntaxValue MeaningMel
        ExamplesetAttr node.doubleArrayAttr -type doubleArray 2 3.14159 2.782;Python
        Examplecmds.setAttr( node.doubleArrayAttr, (2, 3.14159, 2.782,),
        type=doubleArray)-type matrix4x4 matrix of doublesValue Syntaxdouble double
        double doubledouble double double doubledouble double double doubledouble double
        double doubleValue Meaningrow1col1 row1col2 row1col3 row1col4row2col1 row2col2
        row2col3 row2col4row3col1 row3col2 row3col3 row3col4row4col1 row4col2 row4col3
        row4col4Alternate Syntaxstring double double doubledouble double
        doubleintegerdouble double doubledouble double doubledouble double doubledouble
        double doubledouble double doubledouble double doubledouble double double
        doubledouble double double doubledouble double doublebooleanAlternate
        MeaningxformscaleX scaleY scaleZrotateX rotateY rotateZrotationOrder (0=XYZ,
        1=YZX, 2=ZXY, 3=XZY, 4=YXZ, 5=ZYX)translateX translateY translateZshearXY
        shearXZ shearYZscalePivotX scalePivotY scalePivotZscaleTranslationX
        scaleTranslationY scaleTranslationZrotatePivotX rotatePivotY
        rotatePivotZrotateTranslationX rotateTranslationY
        rotateTranslationZrotateOrientW rotateOrientX rotateOrientY
        rotateOrientZjointOrientW jointOrientX jointOrientY
        jointOrientZinverseParentScaleX inverseParentScaleY
        inverseParentScaleZcompensateForParentScale Mel ExamplesetAttr node.matrixAttr
        -type matrix1 0 0 0 0 1 0 0 0 0 1 0 2 3 4 1;setAttr node.matrixAttr -type
        matrixxform1 1 1 0 0 0 0 2 3 4 0 0 00 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 1
        0 false;Python Examplecmds.setAttr('node.matrixAttr',(1,0,0,0,0,1,0,0,0,0,1,0,2,
        3,4,1),type='matrix')cmds.setAttr('node.matrixAttr','xform',(1,1,1),(0,0,0),0,(2
        ,3,4),(0,0,0),(0,0,0),(0,0,0),(0,0,0),(0,1,1),(0,0,1,0),(1,0,1,0),(1,2,3),False,
        type=matrix)-type pointArrayVariable length array of pointsValue SyntaxValue
        MeaningMel ExamplesetAttr node.pointArrayAttr -type pointArray 2 1 1 1 1 2 2 2
        1;Python Examplecmds.setAttr('node.pointArrayAttr',2,(1,1,1,1),(2,2,2,1),type='p
        ointArray')-type vectorArrayVariable length array of vectorsValue SyntaxValue
        MeaningMel ExamplesetAttr node.vectorArrayAttr -type vectorArray 2 1 1 1 2 2
        2;Python Examplecmds.setAttr('node.vectorArrayAttr',2,(1,1,1),(2,2,2),type='vect
        orArray')-type stringCharacter stringValue SyntaxstringValue
        MeaningcharacterStringValueMel ExamplesetAttr node.stringAttr -type
        stringblarg;Python Examplecmds.setAttr('node.stringAttr',blarg,type=string)-type
        stringArrayVariable length array of stringsValue SyntaxValue MeaningMel
        ExamplesetAttr node.stringArrayAttr -type stringArray 3 abc;Python
        Examplecmds.setAttr('node.stringArrayAttr',3,a,b,c,type='stringArray')-type
        sphereSphere dataValue SyntaxdoubleValue MeaningsphereRadiusExamplesetAttr
        node.sphereAttr -type sphere 5.0;-type coneCone dataValue Syntaxdouble
        doubleValue MeaningconeAngle coneCapMel ExamplesetAttr node.coneAttr -type cone
        45.0 5.0;Python Examplecmds.setAttr('node.coneAttr',45.0,5.0,type='cone')-type
        reflectanceRGBReflectance dataValue Syntaxdouble double doubleValue
        MeaningredReflect greenReflect blueReflectMel ExamplesetAttr
        node.reflectanceRGBAttr -type reflectanceRGB 0.5 0.5 0.1;Python Examplecmds.setA
        ttr('node.reflectanceRGBAttr',0.5,0.5,0.1,type='reflectanceRGB')-type
        spectrumRGBSpectrum dataValue Syntaxdouble double doubleValue MeaningredSpectrum
        greenSpectrum blueSpectrumMel ExamplesetAttr node.spectrumRGBAttr -type
        spectrumRGB 0.5 0.5 0.1;Python
        Examplecmds.setAttr('node.spectrumRGBAttr',0.5,0.5,0.1,type='spectrumRGB')-type
        componentListVariable length array of componentsValue SyntaxValue MeaningMel
        ExamplesetAttr node.componentListAttr -type componentList 3 cv[1] cv[12]
        cv[3];Python Examplecmds.setAttr('node.componentListAttr',3,'cv[1]','cv[12]','cv
        [3]',type='componentList')-type attributeAliasString alias dataValue
        Syntaxstring stringValue MeaningnewAlias currentNameMel ExamplesetAttr
        node.attrAliasAttr -type attributeAliasGoUp, translateY, GoLeft,
        translateX;Python Examplecmds.setAttr('node.attrAliasAttr',(GoUp,
        translateY,GoLeft, translateX),type='attributeAlias')-type nurbsCurveNURBS curve
        dataValue SyntaxValue MeaningMel Example// degree is the degree of the
        curve(range 1-7)// spans is the number of spans // form is open (0), closed (1),
        periodic (2)// dimension is 2 or 3, depending on the dimension of the curve//
        isRational is true if the curve CVs contain a rational component // knotCount is
        the size of the knot list//  knotValue is a single entry in the knot list//
        cvCount is the number of CVs in the curve//  xCVValue,yCVValue,[zCVValue]
        [wCVValue] is a single CV.//  zCVValue is only present when dimension is 3.//
        wCVValue is only present when isRational is true.//setAttr node.curveAttr -type
        nurbsCurve 3 1 0 no 36 0 0 0 1 1 14 -2 3 0 -2 1 0 -2 -1 0 -2 -3 0;-type
        nurbsSurfaceNURBS surface dataValue Syntaxint int int int bool Value
        MeaninguDegree vDegree uForm vForm isRationalTRIM|NOTRIMExample// uDegree is
        degree of the surface in U direction (range 1-7)// vDegree is degree of the
        surface in V direction (range 1-7)// uForm is open (0), closed (1), periodic (2)
        in U direction// vForm is open (0), closed (1), periodic (2) in V direction//
        isRational is true if the surface CVs contain a rational component// uKnotCount
        is the size of the U knot list//  uKnotValue is a single entry in the U knot
        list// vKnotCount is the size of the V knot list//  vKnotValue is a single entry
        in the V knot list// If TRIMis specified then additional trim information is
        expected// If NOTRIMis specified then the surface is not trimmed// cvCount is
        the number of CVs in the surface//  xCVValue,yCVValue,zCVValue [wCVValue]is a
        single CV.//  zCVValue is only present when dimension is 3.//  wCVValue is only
        present when isRational is true//setAttr node.surfaceAttr -type nurbsSurface 3 3
        0 0 no 6 0 0 0 1 1 16 0 0 0 1 1 116 -2 3 0 -2 1 0 -2 -1 0 -2 -3 0-1 3 0 -1 1 0
        -1 -1 0 -1 -3 01 3 0 1 1 0 1 -1 0 1 -3 03 3 0 3 1 0 3 -1 0 3 -3 0;-type
        nurbsTrimfaceNURBS trim face dataValue SyntaxValue MeaningExample// flipNormal
        if true turns the surface inside out// boundaryCount: number of boundaries//
        boundaryType: // tedgeCountOnBoundary    : number of edges in a boundary//
        splineCountOnEdge    : number of splines in an edge in// edgeTolerance        :
        tolerance used to build the 3d edge// isEdgeReversed        : if true, the edge
        is backwards// geometricContinuity    : if true, the edge is tangent
        continuous// splineCountOnPedge    : number of splines in a 2d edge// isMonotone
        : if true, curvature is monotone// pedgeTolerance        : tolerance for the 2d
        edge//-type polyFacesPolygon face dataValue SyntaxfhmfmhmumcValue
        MeaningfhmfmhmumcExample// This data type (polyFace) is meant to be used in file
        I/O// after setAttrs have been written out for vertex position// arrays, edge
        connectivity arrays (with corresponding start// and end vertex descriptions),
        texture coordinate arrays and// color arrays.  The reason is that this data type
        references// all of its data through ids created by the former types.////
        fspecifies the ids of the edges making up a face -//     negative value if the
        edge is reversed in the face// hspecifies the ids of the edges making up a hole
        -//     negative value if the edge is reversed in the face// mfspecifies the ids
        of texture coordinates (uvs) for a face.//     This data type is obsolete as of
        version 3.0. It is replaced by mu.// mhspecifies the ids of texture coordinates
        (uvs) for a hole//     This data type is obsolete as of version 3.0. It is
        replaced by mu.// muThe  first argument refers to the uv set. This is a zero-
        based//     integer number. The second argument refers to the number of vertices
        (n)//     on the face which have valid uv values. The last n values are the uv//
        ids of the texture coordinates (uvs) for the face. These indices//     are what
        used to be represented by the mfand mhspecification.//     There may be more
        than one muspecification, one for each unique uv set.// mcspecifies the color
        index values for a face. The first argument//     is color index. The second
        argument is the number of color ids to follow.//     Rest of the arguments are
        color ids for the face.//setAttr node.polyFaceAttr -type polyFaces f3 1 2 3 mc0
        4 0 1 2 3;-type meshPolygonal meshValue SyntaxValue
        Meaningvvn[vtesmooth|hard]Example// vspecifies the vertices of the polygonal
        mesh// vnspecifies the normal of each vertex// vtis optional and specifies a U,V
        texture coordinate for each vertex// especifies the edge connectivity
        information between vertices//setAttr node.meshAttr -type mesh v3 0 0 0 0 1 0 0
        0 1vn3 1 0 0 1 0 0 1 0 0vt3 0 0 0 1 1 0e3 0 1 hard1 2 hard2 0 hard;-type
        latticeLattice dataValue SyntaxValue MeaningsDivisionCount tDivisionCount
        uDivisionCountExample// sDivisionCount is the horizontal lattice division
        count// tDivisionCount is the vertical lattice division count// uDivisionCount
        is the depth lattice division count// pointCount is the total number of lattice
        points// pointX,pointY,pointZ is one lattice point.  The list is//   specified
        varying first in S, then in T, last in U so the//   first two entries are
        (S=0,T=0,U=0) (s=1,T=0,U=0)//setAttr node.latticeAttr -type lattice 2 5 2 20-2
        -2 -2 2 -2 -2 -2 -1 -2 2 -1 -2 -2 0 -22 0 -2 -2 1 -2 2 1 -2 -2 2 -2 2 2 -2-2 -2
        2 2 -2 2 -2 -1 2 2 -1 2 -2 0 22 0 2 -2 1 2 2 1 2 -2 2 2 2 2 2;In query mode,
        return type is based on queried flag.
        
        same as `DependNode.setAttr` with the force flag set to True.  This causes
        the attribute to be created based on the passed input value.
        
        Flags:
        - alteredValue : av              (bool)          [create]
            The value is only the current value, which may change in the next evalution (if
            the attribute has an incoming connection). This flag is only used during file
            I/O, so that attributes with incoming connections do not have their data
            overwritten during the first evaluation after a file is opened.
        
        - caching : ca                   (bool)          [create]
            Sets the attribute's internal caching on or off. Not all attributes can be
            defined as caching. Only those attributes that are not defined by default to be
            cached can be made caching.  As well, multi attribute elements cannot be made
            caching. Caching also affects child attributes for compound attributes.
        
        - capacityHint : ch              (int)           [create]
            Used to provide a memory allocation hint to attributes where the -size flag
            cannot provide enough information. This flag is optional and is primarily
            intended to be used during file I/O. Only certain attributes make use of this
            flag, and the interpretation of the flag value varies per attribute. This flag
            is currently used by (node.attribute): mesh.face - hints the total number of
            elements in the face edge lists
        
        - channelBox : cb                (bool)          [create]
            Sets the attribute's display in the channelBox on or off. Keyable attributes are
            always display in the channelBox regardless of the channelBox settting.
        
        - clamp : c                      (bool)          [create]
            For numeric attributes, if the value is outside the range of the attribute,
            clamp it to the min or max instead of failing
        
        - keyable : k                    (bool)          [create]
            Sets the attribute's keyable state on or off.
        
        - lock : l                       (bool)          [create]
            Sets the attribute's lock state on or off.
        
        - size : s                       (int)           [create]
            Defines the size of a multi-attribute array. This is only a hint, used to help
            allocate memory as efficiently as possible.
        
        - type : typ                     (unicode)       [create]
            Identifies the type of data.  If the -type flag is not present, a numeric type
            is assumed.                  Flag can have multiple arguments, passed either as
            a tuple or a list.
        
        
        Derived from mel command `maya.cmds.setAttr`
        """
        pass
    def setFlag(self, flag, state):
        """
        Sets the state of the specified flag for the node.
        
        Parameters:
        flag : 'int'
            flag to set
        state : 'bool'
            new state to which the flag will be set
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.setFlag`
        """
        pass
    def setIcon(self, filename):
        """
        Associates a custom icon with the node for display in the Maya UI. Currently the icon only shows up in Outliner panels (the DAG Outliner, Graph Editor and Dope Sheet).
        
        Parameters:
        filename : 'unicode'
            specifies the name of the image file defining the icon, or the empty string (i.e. "") to revert to using Maya's default. The filename must be a PNG file (.png) and may either be an absolute pathname or be relative to the XBMLANGPATH environment variable.
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.setIcon`
        """
        pass
    def setLocked(self, lock):
        """
        Locks or unlocks this node.
        
        Parameters:
        lock : 'bool'
            If true then node will be locked.
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.setLocked`
        """
        pass
    def setName(self, name, createNamespace='False'):
        """
        Sets the name of this node.
        
        Parameters:
        name : 'unicode'
            the new name for the node
        createNamespace : 'bool'
            determine whether or not to create a new namespace when the given name includes a namespace which does not exist.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.setName`
        """
        pass
    def shadingGroups(self):
        """
        list any shading groups in the future of this object - works for
        shading nodes, transforms, and shapes
        
        Also see listSets(type=1) - which returns which 'rendering sets' the
        object is a member of (and 'rendering sets' seem to consist only of
        shading groups), whereas this method searches the object's future for
        any nodes of type 'shadingEngine'.
        
        Returns
        -------
        List[ShadingEngine]
        """
        pass
    def shortName(self, **kwargs):
        """
        This produces the same results as `DependNode.name` and is included to
        simplify looping over lists of nodes that include both Dag and Depend
        nodes.
        
        Returns
        -------
        unicode
        """
        pass
    def sources(self, **kwargs):
        """
        listConnections -source 1 -destination 0
        
        Returns
        -------
        List[general.PyNode]
        """
        pass
    def stripNum(self):
        """
        Return the name of the node with trailing numbers stripped off.
        
        If no trailing numbers are found the name will be returned unchanged.
        
        >>> from pymel.core import *
        >>> SCENE.lambert1.stripNum()
        u'lambert'
        
        Returns
        -------
        unicode
        """
        pass
    def type(node, **kwargs):
        """
        This command returns a string which identifies the given node's type. When no
        flags are used, the unique type name is returned.  This can be useful for seeing
        if two nodes are of the same type. When the apiflag is used, the MFn::Type of
        the node is returned. This can be useful for seeing if a plug-in node belongs to
        a given class. The apiflag cannot be used in conjunction with any other flags.
        When the derivedflag is used, the command returns a string array containing the
        names of all the currently known node types which derive from the node type of
        the given object. When the inheritedflag is used, the command returns a string
        array containing the names of all the base node types inherited by the the given
        node. If the isTypeNameflag is present then the argument provided to the command
        is taken to be the name of a node type rather than the name of a specific node.
        This makes it possible to query the hierarchy of node types without needing to
        have instances of each node type.
        
        Note: this will return the dg node type for an object, like maya.cmds.nodeType,
        NOT the pymel PyNode class.  For objects like components or attributes,
        nodeType will return the dg type of the node to which the PyNode is attached.
        
        Returns
        -------
        unicode
        
        Flags:
        - apiType : api                  (bool)          [create]
            Return the MFn::Type value (as a string) corresponding to the given node.  This
            is particularly useful when the given node is defined by a plug-in, since in
            this case, the MFn::Type value corresponds to the underlying proxy class. This
            flag cannot be used in combination with any of the other flags.
        
        - derived : d                    (bool)          [create]
            Return a string array containing the names of all the currently known node types
            which derive from the type of the specified node.
        
        - inherited : i                  (bool)          [create]
            Return a string array containing the names of all the base node types inherited
            by the specified node.
        
        - isTypeName : itn               (bool)          [create]
            If this flag is present, then the argument provided to the command is the name
            of a node type rather than the name of a specific node.                  Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.nodeType`
        """
        pass
    def unlock(self, **kwargs):
        """
        lockNode -lock 0
        """
        pass
    @classmethod
    def allocateFlag(self, pluginName):
        """
        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.
        
        Parameters:
        pluginName : 'unicode'
            The name of the plugin which is allocating the flag. A plugin's name can be retrieved by calling MFnPlugin::name() within its initializePlugin() or uninitializePlugin() functions.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.allocateFlag`
        """
        pass
    @classmethod
    def deallocateAllFlags(self, pluginName):
        """
        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.
        
        Parameters:
        pluginName : 'unicode'
            The name of the plugin whose flags are to be deallocated. A plugin's name can be retrieved by calling MFnPlugin::name() within its initializePlugin() or uninitializePlugin() functions.
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.deallocateAllFlags`
        """
        pass
    @classmethod
    def deallocateFlag(self, pluginName, flag):
        """
        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.
        
        Parameters:
        pluginName : 'unicode'
            The name of the plugin which allocated the flag. A plugin's name can be retrieved by calling MFnPlugin::name() within its initializePlugin() or uninitializePlugin() functions.
        flag : 'int'
            Flag to deallocate.
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.deallocateFlag`
        """
        pass
    @classmethod
    def enableDGTiming(self, enable):
        """
        Globally enables or disables the DG node timing mechanism. There are two levels of control for DG node timing. dgTimerOn() and dgTimerOff() are used to determine which nodes are eligible for timer data collection and this method is used to globally enable or disable the DG node timing mechanism.
        
        Parameters:
        enable : 'bool'
            flag to turn timing on or off.
        
        Derived from api method `maya.OpenMaya.MFnDependencyNode.enableDGTiming`
        """
        pass
    @classmethod
    def registerVirtualSubClass(cls, nameRequired='False'):
        """
        Deprecated
        """
        pass
    @classmethod
    def typeName(cls):
        """
        Similar to type / nodeType, but a classmethod that does no dynamic
        querying
        """
        pass
    MAttrClass = {}
    
    
    MdgTimerMetric = {}
    
    
    MdgTimerState = {}
    
    
    MdgTimerType = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = 'dependNode'
    
    
    
    
    __readonly__ = {}


import pymel.util as _util

class NodetypesLazyLoadModule(_util.LazyLoadModule):
    """
    Like a standard lazy load  module, but with dynamic PyNode class creation
    """
    
    
    
    def __getattr__(self, name):
        """
        Check to see if the name corresponds to a PyNode that hasn't been
        added yet
        """
        pass


class TimeEditorClipEvaluator(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class LodThresholds(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeEditor(DependNode):
    def getMute(self, **kwargs):
        """
        Mute/unmute Time Editor.                                   
        
        
        Derived from mel command `maya.cmds.timeEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        General Time Editor commands
        
        Flags:
        - allClips : alc                 (unicode)       [create]
            Return an exhaustive (recursive) list of all clip IDs from the active
            composition. Arguments may be used to filter the returning result. An empty
            string will return clip IDs for all clip types: roster container group
        
        - clipId : id                    (int)           [create]
            ID of the clip to be edited.
        
        - commonParentTrack : cpt        (bool)          [create]
            Locate the common parent track node and track index of the given clip IDs.
            Requires a list of clip IDs to be specified using the clipId flag. The format of
            the returned string is track_node:track_index. If the clips specified are on the
            same track node but in different track indexes, only the track node will be
            returned.
        
        - composition : cp               (unicode)       [create]
            A flag to use in conjunction with -dca/drivingClipsForObjto indicate the name of
            composition to use. By default if this flag is not provided, current active
            composition will be used.
        
        - drivingClipsForAttr : dca      (unicode)       [create]
            Return a list of clips driving the specified attribute(s). If the composition is
            not specified, current active composition will be used.
        
        - drivingClipsForObj : dco       (unicode, int)  [create]
            Return a list of clips driving the specified object(s) with an integer value
            indicating the matching mode. If no object is specified explicitly, the selected
            object(s) will be used. Objects that cannot be driven by clips are ignored. If
            the composition is not specified, current active composition will be used.
            Default match mode is 0. 0: Include only the clip that has an exact match1:
            Include any clip that contains all of the specified objects2: Include any clip
            that contains any of the specified objects3: Include all clips that do not
            include any of the specified objects
        
        - includeParent : ip             (bool)          [create]
            A toggle flag to use in conjunction with -dca/drivingClipsForObj. When toggled,
            parent clip is included in selection (the entire hierarchy will be selected).
        
        - mute : m                       (bool)          [create,query]
            Mute/unmute Time Editor.
        
        - selectedClips : sc             (unicode)       [create]
            Return a list of clip IDs of currently selected Time Editor clips. Arguments may
            be used to filter the returning result. An empty string will return clip IDs for
            all clip types: roster container group
        
        - topLevelClips : tlc            (unicode)       [create]
            Return a list of all top-level clip IDs from the active composition. Arguments
            may be used to filter the returning result. An empty string will return clip IDs
            for all clip types: roster container group Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.timeEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CharacterOffset(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class NodeGraphEditorBookmarkInfo(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyBase(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Luminance(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PostProcessList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class NodeGraphEditorInfo(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class HardwareRenderGlobals(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderPassSet(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ShaderGlow(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CharacterMap(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getMapAttr(self, **kwargs):
        """
        In query mode, this flag can be used to query the mapping stored by the specified map node. It returns an array of strings. In non-query mode, this flag can be used to create a mapping between the specified character members. Any previous mapping on the attributes is removed in favor of the newly specified mapping.                               
        
        
        Derived from mel command `maya.cmds.characterMap`
        """
        pass
    def getMapNode(self, **kwargs):
        """
        This flag can be used to map all the attributes on the source node to their matching attributes on the destination node.                                   
        
        
        Derived from mel command `maya.cmds.characterMap`
        """
        pass
    def getMapping(self, **kwargs):
        """
        This flag is valid in query mode only. It must be used before the query flag with a string argument. It is used for querying the mapping for a particular attribute.  A string array is returned.                                  
        
        
        Derived from mel command `maya.cmds.characterMap`
        """
        pass
    def getProposedMapping(self, **kwargs):
        """
        This flag is valid in query mode only. It is used to get an array of the mapping that the character map would prvide if called with the specified characters and the (optional) specified mappingMethod. If a character map exists on the characters, the map is not affected by the query operation.  A string array is returned.                                 
        
        
        Derived from mel command `maya.cmds.characterMap`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setMapAttr(self, val='True', **kwargs):
        """
        In query mode, this flag can be used to query the mapping stored by the specified map node. It returns an array of strings. In non-query mode, this flag can be used to create a mapping between the specified character members. Any previous mapping on the attributes is removed in favor of the newly specified mapping.                               
        
        
        Derived from mel command `maya.cmds.characterMap`
        """
        pass
    def unmapAttr(self, val='True', **kwargs):
        """
        This flag can be used to unmap the mapping stored by the specified map node.                               
        
        
        Derived from mel command `maya.cmds.characterMap`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create a correlation between the attributes of 2 or more
        characters.
        
        Flags:
        - mapAttr : ma                   (unicode, unicode) [create,query,edit]
            In query mode, this flag can be used to query the mapping stored by the
            specified map node. It returns an array of strings. In non-query mode, this flag
            can be used to create a mapping between the specified character members. Any
            previous mapping on the attributes is removed in favor of the newly specified
            mapping.
        
        - mapMethod : mm                 (unicode)       [create]
            This is is valid in create mode only. It specifies how the mapping should be
            done. Valid options are: byNodeName, byAttrName, and byAttrOrder. byAttrOrderis
            the default. The flags mean the following: byAttrOrdermaps using the order that
            the character stores the attributes internally, byAttrNameuses the attribute
            name to find a correspondence, byNodeNameuses the node name \*and\* the
            attribute name to find a correspondence.
        
        - mapNode : mn                   (unicode, unicode) [create,query]
            This flag can be used to map all the attributes on the source node to their
            matching attributes on the destination node.
        
        - mapping : m                    (unicode)       [query]
            This flag is valid in query mode only. It must be used before the query flag
            with a string argument. It is used for querying the mapping for a particular
            attribute.  A string array is returned.
        
        - proposedMapping : pm           (bool)          [query]
            This flag is valid in query mode only. It is used to get an array of the mapping
            that the character map would prvide if called with the specified characters and
            the (optional) specified mappingMethod. If a character map exists on the
            characters, the map is not affected by the query operation.  A string array is
            returned.
        
        - unmapAttr : ua                 (unicode, unicode) [create,edit]
            This flag can be used to unmap the mapping stored by the specified map node.
        
        - unmapNode : umn                (unicode, unicode) [create]
            This flag can be used to unmap all the attributes on the source node to their
            matching attributes on the destination node. Note that mapped attributes which
            do not have matching names, will not be unmapped.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.characterMap`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NComponent(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TextureToGeom(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DisplayLayer(DependNode):
    def addMembers(self, members, noRecurse='True'): pass
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def listMembers(self, fullNames='True'): pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def removeMembers(self, members, noRecurse='True'): pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setCurrent(self): pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a new display layer.  The display layer number will be assigned based on
        the first unassigned number not less than the base index number found in the
        display layer global parameters.  Normally all objects and their descendants
        will be added to the new display layer but if the '-nr' flag is specified then
        only the objects themselves will be added.
        
        Flags:
        - empty : e                      (bool)          [create]
            If set then create an empty display layer.  ie. Do not add the selected items to
            the new display layer.
        
        - makeCurrent : mc               (bool)          [create]
            If set then make the new display layer the current one.
        
        - name : n                       (unicode)       [create]
            Name of the new display layer being created.
        
        - noRecurse : nr                 (bool)          [create]
            If set then only add selected objects to the display layer.  Otherwise all
            descendants of the selected objects will also be added.
        
        - number : num                   (int)           [create]
            Number for the new display layer being created.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.createDisplayLayer`
        """
        pass
    @staticmethod
    def __new__(cls, *args, **kwargs): pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'createDisplayLayer'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Choice(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getIndex(self, **kwargs):
        """
        specifies the multi-input index of the choice node to connect the source attribute to. When queried, returns a list of integers one per specified -t/time that indicates the multi-index of the choice node to use at that time.                  
        
        
        Derived from mel command `maya.cmds.choice`
        """
        pass
    def getSelector(self, **kwargs):
        """
        specifies the attribute to be used as the choice node's selector. The value of the selector at a given time determines which of the choice node's multi-indices should be used as the output of the choice node at that time. This flag is only editable (it cannot be specified at creation time). When queried, returns a list of strings.                  
        
        
        Derived from mel command `maya.cmds.choice`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The choice command provides a mechanism for changing the inputs to an attribute
        based on some (usually time-based) criteria. For example, an object could be
        animated from frames 1 to 30 by a motion path, then from frames 30 to 50 it
        follows keyframe animation, and after frame 50 it returns to the motion path.
        Or, a revolve surface could change its input curve depending on some transform's
        rotation value.The choice command creates a choice node (if one does not already
        exist) on all specified attributes of the selected objects. If the attribute was
        already connected to something, that something is now reconnected to the i'th
        index of the choice node's input (or the next available input if the -in/index
        flag is not specified). If a source attribute is specified, then that attribute
        is connected to the choice node's i'th input instead.The choice node operates by
        using the value of its selector attribute to determine which of its input
        attributes to pass through to its output. The input attributes can be of any
        type. For example, if the selector attribute was connected by an animation curve
        with keyframes at (1,1), (30,2) and (50,1), then that would mean that the choice
        node would pass on the data from input[1] from time 1 to 30, and after time 50,
        and the data from input[2] between times 30 and 50.This command returns the
        names of the created or modified choice nodes, and if a keyframe was added to
        the animation curve, it specifies the index (or value on the animation curve).
        
        Flags:
        - attribute : at                 (unicode)       [create]
            specifies the attributes onto which choice node(s) should be created. The
            default is all keyable attributes of the given objects. Note that although this
            flag is not queryable, it can be used to qualify which attributes of the given
            objects to query.
        
        - controlPoints : cp             (bool)          [create]
            Explicitly specify whether or not to include the control points of a shape (see
            -sflag) in the list of attributes. Default: false.
        
        - index : index                  (int)           [create,query]
            specifies the multi-input index of the choice node to connect the source
            attribute to. When queried, returns a list of integers one per specified -t/time
            that indicates the multi-index of the choice node to use at that time.
        
        - name : n                       (unicode)       [create,query]
            the name to give to any newly created choice node(s). When queried, returns a
            list of strings.
        
        - selector : sl                  (PyNode)        [create,query]
            specifies the attribute to be used as the choice node's selector. The value of
            the selector at a given time determines which of the choice node's multi-indices
            should be used as the output of the choice node at that time. This flag is only
            editable (it cannot be specified at creation time). When queried, returns a list
            of strings.
        
        - shape : s                      (bool)          [create]
            Consider all attributes of shapes below transforms as well, except
            controlPoints. Default: true
        
        - sourceAttribute : sa           (PyNode)        [create]
            specifies the attribute to connect to the choice node that will be selected at
            the given time(s) specified by -t/time.
        
        - time : t                       (time)          [create]
            specifies the time at which the choice should use the given source attribute, or
            the currently connected attribute if source attribute is not specified. The
            default is the curren time. Note that although this flag is not queryable, it
            can be used to qualify the times at which to query the other attributes.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.choice`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class UnitConversion(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class HyperLayout(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ClipScheduler(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Contrast(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Bump3d(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class HierarchyTestNode1(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ParticleTranspMapper(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdivToPoly(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AngleBetween(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs): pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DefaultLightList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class HsvToRgb(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ImageSource(DependNode):
    def sourceCamera(self, currentCamera):
        """
        Parameters:
        currentCamera : 'PyNode'
            
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaRender.MFnImageSource.sourceCamera`
        """
        pass
    def sourceLayer(self, currentLayer):
        """
        Parameters:
        currentLayer : 'PyNode'
            
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaRender.MFnImageSource.sourceLayer`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Controller(DependNode):
    def getAllControllers(self, **kwargs):
        """
        When this flag is queried, returns all dependNode attached to a controller in the scene.                                   
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getChildren(self, **kwargs):
        """
        Return true if the specified dependNode is a controller.                                   
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getGroup(self, **kwargs):
        """
        Create a controller that is not associated with any object. This new controller will be the parent of all the selected objects.                                    
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getIndex(self, **kwargs):
        """
        In query mode, returns the index of the controller in the parent controller's list of children. In edit mode, reorder the parent controller's children connections so that the current controller is assigned the given index.                             
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getIsController(self, **kwargs):
        """
        Returns true if the specified dependNode is a controller.                                  
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getParent(self, **kwargs):
        """
        Set or query the parent controller of the selected controller node.                                
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getPickWalkDown(self, **kwargs):
        """
        Return the first child.                                    
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getPickWalkLeft(self, **kwargs):
        """
        Return the previous sibling.                               
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getPickWalkRight(self, **kwargs):
        """
        Return the next sibling.                                   
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getPickWalkUp(self, **kwargs):
        """
        Return the parent.                                 
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def getUnparent(self, **kwargs):
        """
        Unparent all selected controller objects from their respective parent.                             Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setAllControllers(self, val='True', **kwargs):
        """
        When this flag is queried, returns all dependNode attached to a controller in the scene.                                   
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setChildren(self, val='True', **kwargs):
        """
        Return true if the specified dependNode is a controller.                                   
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setGroup(self, val='True', **kwargs):
        """
        Create a controller that is not associated with any object. This new controller will be the parent of all the selected objects.                                    
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setIndex(self, val='True', **kwargs):
        """
        In query mode, returns the index of the controller in the parent controller's list of children. In edit mode, reorder the parent controller's children connections so that the current controller is assigned the given index.                             
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setIsController(self, val='True', **kwargs):
        """
        Returns true if the specified dependNode is a controller.                                  
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Set or query the parent controller of the selected controller node.                                
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setPickWalkDown(self, val='True', **kwargs):
        """
        Return the first child.                                    
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setPickWalkLeft(self, val='True', **kwargs):
        """
        Return the previous sibling.                               
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setPickWalkRight(self, val='True', **kwargs):
        """
        Return the next sibling.                                   
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setPickWalkUp(self, val='True', **kwargs):
        """
        Return the parent.                                 
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    def setUnparent(self, val='True', **kwargs):
        """
        Unparent all selected controller objects from their respective parent.                             Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Commands for managing animation sources
        
        Flags:
        - allControllers : ac            (bool)          [create,query,edit]
            When this flag is queried, returns all dependNode attached to a controller in
            the scene.
        
        - children : cld                 (bool)          [query,edit]
            Return true if the specified dependNode is a controller.
        
        - group : g                      (bool)          [create,query,edit]
            Create a controller that is not associated with any object. This new controller
            will be the parent of all the selected objects.
        
        - index : idx                    (int)           [query,edit]
            In query mode, returns the index of the controller in the parent controller's
            list of children. In edit mode, reorder the parent controller's children
            connections so that the current controller is assigned the given index.
        
        - isController : ic              (unicode)       [create,query,edit]
            Returns true if the specified dependNode is a controller.
        
        - parent : p                     (bool)          [create,query,edit]
            Set or query the parent controller of the selected controller node.
        
        - pickWalkDown : pwd             (bool)          [query,edit]
            Return the first child.
        
        - pickWalkLeft : pwl             (bool)          [query,edit]
            Return the previous sibling.
        
        - pickWalkRight : pwr            (bool)          [query,edit]
            Return the next sibling.
        
        - pickWalkUp : pwu               (bool)          [query,edit]
            Return the parent.
        
        - unparent : unp                 (bool)          [query,edit]
            Unparent all selected controller objects from their respective parent.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.controller`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeEditorClipBase(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class LightLinker(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeBase(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CreateColorSet(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class FrameCache(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DefaultTextureList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeEditorTracks(DependNode):
    def addTrack(self, val='True', **kwargs):
        """
        Add new track at the track index specified. Indices are 0-based. Specify -1 to add the track at the end.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getActiveClipWeight(self, **kwargs):
        """
        Get the clip weight at the specified time.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getActiveClipWeightId(self, **kwargs):
        """
        Get the clip ID carrying the active clip weight at the specified time.                             
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getAllClips(self, **kwargs):
        """
        Return a list of clip IDs under the specified track.                               
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getAllTracks(self, **kwargs):
        """
        Return a list of strings for all the immediate tracks for the given tracks node in the format tracksNode:trackIndex.                               
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getAllTracksRecursive(self, **kwargs):
        """
        Return a list of strings for all the tracks for the given tracks node, or return a list of strings for all tracks of all tracks nodes in the format tracksNode:trackIndex. If the given root tracks node is from a composition, this command returns the tracks under that composition, including the tracks within groups that is under the same composition.                             
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getComposition(self, **kwargs):
        """
        Return the composition the specified track belongs to.                             
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getPlugIndex(self, **kwargs):
        """
        Get the plug index of the specified track.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getSelectedTracks(self, **kwargs):
        """
        Return a list of the indices for all the selected tracks for the given tracks node, or return a list of strings for all selected tracks of all tracks nodes in the format tracksNode:trackIndex.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getTrackGhost(self, **kwargs):
        """
        Ghost all clips under track.                               
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getTrackIndex(self, **kwargs):
        """
        Specify the track index. This flag is used in conjunction with the other flags. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getTrackMuted(self, **kwargs):
        """
        Return whether the track is muted.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getTrackName(self, **kwargs):
        """
        Display name of the track.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getTrackSolo(self, **kwargs):
        """
        Return whether the track is soloed.                                
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def getTrackType(self, **kwargs):
        """
        Specify the track type. Can only be used together with -at/addTrack. Does not work by itself. In query mode, return the integer corresponding to the track type. 0: Animation Track (Default)1: Audio Track Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def path(self, val='True', **kwargs):
        """
        Full path of a track node or a track on which to operate. For example: composition1|track1|group; composition1|track1. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def removeTrack(self, val='True', **kwargs):
        """
        Remove track at given index. It is a multi-use flag.                               
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def removeTrackByPath(self, val='True', **kwargs):
        """
        Remove track at given path. It is a multi-use flag. For example: composition1|track1|group|track1;                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def reorderTrack(self, val='True', **kwargs):
        """
        Move the track relative to other tracks. The first argument is the track index (0-based). The second argument can be a positive or negative number to indicate the steps to move. Positive numbers move forward and negative numbers move backward.                                
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def setPlugIndex(self, val='True', **kwargs):
        """
        Get the plug index of the specified track.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def setTrackGhost(self, val='True', **kwargs):
        """
        Ghost all clips under track.                               
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def setTrackIndex(self, val='True', **kwargs):
        """
        Specify the track index. This flag is used in conjunction with the other flags. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def setTrackMuted(self, val='True', **kwargs):
        """
        Return whether the track is muted.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def setTrackName(self, val='True', **kwargs):
        """
        Display name of the track.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def setTrackSolo(self, val='True', **kwargs):
        """
        Return whether the track is soloed.                                
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    def setTrackType(self, val='True', **kwargs):
        """
        Specify the track type. Can only be used together with -at/addTrack. Does not work by itself. In query mode, return the integer corresponding to the track type. 0: Animation Track (Default)1: Audio Track Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Time Editor tracks commands
        
        Flags:
        - activeClipWeight : acw         (time)          [query]
            Get the clip weight at the specified time.
        
        - activeClipWeightId : aci       (time)          [query]
            Get the clip ID carrying the active clip weight at the specified time.
        
        - addTrack : at                  (int)           [edit]
            Add new track at the track index specified. Indices are 0-based. Specify -1 to
            add the track at the end.
        
        - allClips : ac                  (bool)          [query]
            Return a list of clip IDs under the specified track.
        
        - allTracks : atc                (bool)          [query]
            Return a list of strings for all the immediate tracks for the given tracks node
            in the format tracksNode:trackIndex.
        
        - allTracksRecursive : atr       (bool)          [query]
            Return a list of strings for all the tracks for the given tracks node, or return
            a list of strings for all tracks of all tracks nodes in the format
            tracksNode:trackIndex. If the given root tracks node is from a composition, this
            command returns the tracks under that composition, including the tracks within
            groups that is under the same composition.
        
        - composition : cp               (bool)          [query]
            Return the composition the specified track belongs to.
        
        - path : pt                      (unicode)       [edit]
            Full path of a track node or a track on which to operate. For example:
            composition1|track1|group; composition1|track1. In query mode, this flag can
            accept a value.
        
        - plugIndex : pi                 (int)           [query,edit]
            Get the plug index of the specified track.
        
        - removeTrack : rt               (int)           [edit]
            Remove track at given index. It is a multi-use flag.
        
        - removeTrackByPath : rtp        (unicode)       [edit]
            Remove track at given path. It is a multi-use flag. For example:
            composition1|track1|group|track1;
        
        - reorderTrack : rot             (int, int)      [edit]
            Move the track relative to other tracks. The first argument is the track index
            (0-based). The second argument can be a positive or negative number to indicate
            the steps to move. Positive numbers move forward and negative numbers move
            backward.
        
        - resetMute : rm                 (bool)          [create]
            Reset all the muted tracks in the active composition.
        
        - resetSolo : rs                 (bool)          [create]
            Reset the soloing of all tracks on the active composition.
        
        - selectedTracks : st            (bool)          [query]
            Return a list of the indices for all the selected tracks for the given tracks
            node, or return a list of strings for all selected tracks of all tracks nodes in
            the format tracksNode:trackIndex.
        
        - trackGhost : tgh               (bool)          [query,edit]
            Ghost all clips under track.
        
        - trackIndex : ti                (int)           [query,edit]
            Specify the track index. This flag is used in conjunction with the other flags.
            In query mode, this flag can accept a value.
        
        - trackMuted : tm                (bool)          [query,edit]
            Return whether the track is muted.
        
        - trackName : tn                 (unicode)       [query,edit]
            Display name of the track.
        
        - trackSolo : ts                 (bool)          [query,edit]
            Return whether the track is soloed.
        
        - trackType : tt                 (int)           [query,edit]
            Specify the track type. Can only be used together with -at/addTrack. Does not
            work by itself. In query mode, return the integer corresponding to the track
            type. 0: Animation Track (Default)1: Audio Track Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.timeEditorTracks`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderLayerManager(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeEditorAnimSource(DependNode):
    def addSource(self, val='True', **kwargs):
        """
        Add single new target attribute with its animation.                                
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def apply(self, val='True', **kwargs):
        """
        Connect anim source's animation directly to the target objects. If the Time Editor is not muted, connect to scene storage instead.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def bakeToAnimSource(self, val='True', **kwargs):
        """
        Create a new anim source with the same animation as this anim source. All non-curve inputs will be baked down, whereas curve sources will be shared.                               
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def copyAnimation(self, val='True', **kwargs):
        """
        Copy animation when adding source.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def exclusive(self, val='True', **kwargs):
        """
        Populate all types of animation sources which are not listed by typeFlag.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def export(self, val='True', **kwargs):
        """
        Export given anim source and the animation curves to a specified Maya file.                                
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getAddObjects(self, **kwargs):
        """
        Populate the given object(s) and their attributes to anim source to Time Editor. For multiple object, pass each name separated by semicolon. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames for the given object(s). Similar to -addSelectedObjectsflag but acts on given object(s) instead. This flag will override the flag -addSelectedObjects.                                
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getAddRelatedKG(self, **kwargs):
        """
        During population, determine if associated keying groups should be populated or not. Normally used for populating HIK. By default the value is false.                              
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getAddSelectedObjects(self, **kwargs):
        """
        Populate the currently selected objects and their attributes to anim source or Time Editor. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames.                               
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getCalculateTiming(self, **kwargs):
        """
        Adjust start/duration when adding/removing sources. If query it returns the [start,duration] pair.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getDrivenClips(self, **kwargs):
        """
        Return all clips driven by the given anim source.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Return true if the anim source node is only driving a single clip.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getTargetIndex(self, **kwargs):
        """
        Get target index.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getTargets(self, **kwargs):
        """
        Get a list of all targets in this anim source.                             
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def getType(self, **kwargs):
        """
        Only populate the specified type of animation source.                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def importOption(self, val='True', **kwargs):
        """
        Option for importing animation source. Specify either 'connect' or 'generate'. connect:  Only connect with nodes already existing in the scene.                   Importing an animation source that does not match with any element                   of the current scene will not create any clip.                   (connect is the default mode). generate: Import everything and generate new nodes for items not existing in the scene.                             
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def importPopulateOption(self, val='True', **kwargs):
        """
        Option for population when importing.                              
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def includeRoot(self, val='True', **kwargs):
        """
        Populate transform (Translate, Rotate, Scale) of hierarchy root nodes.                             
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def populateAttribute(self, val='True', **kwargs):
        """
        Populate a specific attribute on a object.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def recursively(self, val='True', **kwargs):
        """
        Populate selection recursively, adding all the children.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def removeSceneAnimation(self, val='True', **kwargs):
        """
        If true, remove animation from scene when creating clips or anim sources. Only Time Editor will drive the removed scene animation.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def removeSource(self, val='True', **kwargs):
        """
        Remove single attribute.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def setAddObjects(self, val='True', **kwargs):
        """
        Populate the given object(s) and their attributes to anim source to Time Editor. For multiple object, pass each name separated by semicolon. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames for the given object(s). Similar to -addSelectedObjectsflag but acts on given object(s) instead. This flag will override the flag -addSelectedObjects.                                
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def setAddRelatedKG(self, val='True', **kwargs):
        """
        During population, determine if associated keying groups should be populated or not. Normally used for populating HIK. By default the value is false.                              
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def setAddSelectedObjects(self, val='True', **kwargs):
        """
        Populate the currently selected objects and their attributes to anim source or Time Editor. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames.                               
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def setCalculateTiming(self, val='True', **kwargs):
        """
        Adjust start/duration when adding/removing sources. If query it returns the [start,duration] pair.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    def setType(self, val='True', **kwargs):
        """
        Only populate the specified type of animation source.                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Commands for managing animation sources.
        
        Flags:
        - addObjects : ao                (unicode)       [create,query,edit]
            Populate the given object(s) and their attributes to anim source to Time Editor.
            For multiple object, pass each name separated by semicolon. In query mode,
            return the number of attributes that will be populated given the flags, along
            with the animation's first and last frames for the given object(s). Similar to
            -addSelectedObjectsflag but acts on given object(s) instead. This flag will
            override the flag -addSelectedObjects.
        
        - addRelatedKG : akg             (bool)          [create,query,edit]
            During population, determine if associated keying groups should be populated or
            not. Normally used for populating HIK. By default the value is false.
        
        - addSelectedObjects : aso       (bool)          [create,query,edit]
            Populate the currently selected objects and their attributes to anim source or
            Time Editor. In query mode, return the number of attributes that will be
            populated given the flags, along with the animation's first and last frames.
        
        - addSource : asc                (unicode)       [edit]
            Add single new target attribute with its animation.
        
        - apply : ap                     (bool)          [edit]
            Connect anim source's animation directly to the target objects. If the Time
            Editor is not muted, connect to scene storage instead.
        
        - attribute : at                 (unicode)       [create,edit]
            Populate a specific attribute on a object.
        
        - bakeToAnimSource : bas         (unicode)       [edit]
            Create a new anim source with the same animation as this anim source. All non-
            curve inputs will be baked down, whereas curve sources will be shared.
        
        - calculateTiming : ct           (bool)          [query,edit]
            Adjust start/duration when adding/removing sources. If query it returns the
            [start,duration] pair.
        
        - copyAnimation : cp             (bool)          [edit]
            Copy animation when adding source.
        
        - drivenClips : dc               (bool)          [query]
            Return all clips driven by the given anim source.
        
        - exclusive : exc                (bool)          [create,edit]
            Populate all types of animation sources which are not listed by typeFlag.
        
        - export : ex                    (unicode)       [edit]
            Export given anim source and the animation curves to a specified Maya file.
        
        - importAllFbxTakes : aft        (bool)          [create]
            Import all FBX takes into the new anim sources (for timeEditorAnimSource
            command) or new containers (for timeEditorClip command).
        
        - importFbx : fbx                (unicode)       [create]
            Import an animation from FBX file into the new anim source (for
            timeEditorAnimSource command) or new container (for timeEditorClip command).
        
        - importFbxTakes : ft            (unicode)       [create]
            Import multiple FBX takes (separated by semicolons) into the new anim sources
            (for timeEditorAnimSource command) or new containers (for timeEditorClip
            command).
        
        - importMayaFile : mf            (unicode)       [create]
            Import an animation from Maya file into the new anim sources (for
            timeEditorAnimSource command) or new containers (for timeEditorClip command).
        
        - importOption : io              (unicode)       [edit]
            Option for importing animation source. Specify either 'connect' or 'generate'.
            connect:  Only connect with nodes already existing in the scene.
            Importing an animation source that does not match with any element
            of the current scene will not create any clip.                   (connect is the
            default mode). generate: Import everything and generate new nodes for items not
            existing in the scene.
        
        - importPopulateOption : ipo     (unicode)       [edit]
            Option for population when importing.
        
        - importedContainerNames : icn   (unicode)       [create]
            Internal use only. To be used along with populateImportedAnimSourcesto specify
            names for the created containers.
        
        - includeRoot : irt              (bool)          [create,edit]
            Populate transform (Translate, Rotate, Scale) of hierarchy root nodes.
        
        - isUnique : iu                  (bool)          [query]
            Return true if the anim source node is only driving a single clip.
        
        - populateImportedAnimSources : pia (unicode)       [create]
            Internal use only. Populate the Time Editor with clips using the Animation
            Sources specified (use ; as a delimiter for multiple anim sources).
        
        - poseClip : poc                 (bool)          [create]
            Populate as pose clip with current attribute values.
        
        - recursively : rec              (bool)          [create,edit]
            Populate selection recursively, adding all the children.
        
        - removeSceneAnimation : rsa     (bool)          [create,edit]
            If true, remove animation from scene when creating clips or anim sources. Only
            Time Editor will drive the removed scene animation.
        
        - removeSource : rs              (unicode)       [edit]
            Remove single attribute.
        
        - showAnimSourceRemapping : sar  (bool)          [create]
            Show a remapping dialog when the imported anim source attributes do not match
            the scene attributes.
        
        - takeList : tl                  (unicode)       [create]
            Internal use only. To be used along with populateImportedAnimSourcesto specify
            the imported take names.
        
        - takesToImport : toi            (unicode)       [create]
            Internal use only. To be used along with populateImportedAnimSourcesto specify
            the imported take indices.
        
        - targetIndex : ti               (unicode)       [query]
            Get target index.
        
        - targets : trg                  (bool)          [query]
            Get a list of all targets in this anim source.
        
        - type : typ                     (unicode)       [create,query,edit]
            Only populate the specified type of animation source.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.timeEditorAnimSource`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromMesh(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class NodeGraphEditorBookmarks(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class ParticleIncandMapper(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectFilter(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ParticleAgeMapper(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CreateUVSet(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class HoldMatrix(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DagPose(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getAtPose(self, **kwargs):
        """
        Query whether the hierarchy is at same position as the pose. Names of hierarchy members that are not at the pose position will be returned. An empty return list indicates that the hierarchy is at the pose.                  
        
        
        Derived from mel command `maya.cmds.dagPose`
        """
        pass
    def getBindPose(self, **kwargs):
        """
        Used to specify the bindPose for the selected hierarchy. Each hierarchy can have only a single bindPose, which is saved automatically at the time of a skin bind. The bindPose is used when adding influence objects, binding new skins, or adding flexors. Take care when modifying the bindPose with the -rs/-reset or -rm/-remove flags, since if the bindPose is ill-defined it can cause problems with subsequent skinning operations.                  
        
        
        Derived from mel command `maya.cmds.dagPose`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getMembers(self, **kwargs):
        """
        Query the members of the specified pose. The pose should be specified using the selection list, the -bp/-bindPose or the -n/-name flag.                  
        
        
        Derived from mel command `maya.cmds.dagPose`
        """
        pass
    def getSelection(self, **kwargs):
        """
        Whether or not to store a pose for all items in the hierarchy, or for only the selected items.                  
        
        
        Derived from mel command `maya.cmds.dagPose`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to save and restore the matrix information for a dag
        hierarchy. Specifically, the data stored will restore the translate, rotate,
        scale, scale pivot, rotate pivot, rotation order, and (for joints) joint order
        for all the objects on the hierarchy. Data for other attributes is not stored by
        this command. This command can also be used to store a bindPose for an object.
        When you skin an object, a dagPose is automatically created for the skin.
        
        Flags:
        - addToPose : a                  (bool)          [create]
            Allows adding the selected items to the dagPose.
        
        - atPose : ap                    (bool)          [query]
            Query whether the hierarchy is at same position as the pose. Names of hierarchy
            members that are not at the pose position will be returned. An empty return list
            indicates that the hierarchy is at the pose.
        
        - bindPose : bp                  (bool)          [create,query]
            Used to specify the bindPose for the selected hierarchy. Each hierarchy can have
            only a single bindPose, which is saved automatically at the time of a skin bind.
            The bindPose is used when adding influence objects, binding new skins, or adding
            flexors. Take care when modifying the bindPose with the -rs/-reset or
            -rm/-remove flags, since if the bindPose is ill-defined it can cause problems
            with subsequent skinning operations.
        
        - g : g                          (bool)          [create]
            This flag can be used in conjunction with the restore flag to signal that the
            members of the pose should be restored to the global pose. The global pose means
            not only is each object locally oriented with respect to its parents, it is also
            in the same global position that it was at when the pose was saved. If a
            hierarchy's parenting has been changed since the time that the pose was saved,
            you may have trouble reaching the global pose.
        
        - members : m                    (bool)          [query]
            Query the members of the specified pose. The pose should be specified using the
            selection list, the -bp/-bindPose or the -n/-name flag.
        
        - name : n                       (unicode)       [create,query]
            Specify the name of the pose. This can be used during create, restore, reset,
            remove, and query operations to specify the pose to be created or acted upon.
        
        - remove : rm                    (bool)          [create]
            Remove the selected joints from the specified pose.
        
        - reset : rs                     (bool)          [create]
            Reset the pose on the selected joints. If you are resetting pose data for a
            bindPose, take care. It is appropriate to use the -rs/-reset flag if a joint has
            been reparented and/or appears to be exactly at the bindPose. However, a
            bindPose that is much different from the exact bindPose can cause problems with
            subsequent skinning operations.
        
        - restore : r                    (bool)          [create]
            Restore the hierarchy to a saved pose. To specify the pose, select the pose
            node, or use the -bp/-bindPose or -n/-name flag.
        
        - save : s                       (bool)          [create]
            Save a dagPose for the selected dag hierarchy. The name of the new pose will be
            returned.
        
        - selection : sl                 (bool)          [create,query]
            Whether or not to store a pose for all items in the hierarchy, or for only the
            selected items.
        
        - worldParent : wp               (bool)          [create]
            Indicates that the selected pose member should be recalculated as if it is
            parented to the world. This is typically used when you plan to reparent the
            object to world as the next operation.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.dagPose`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TrackInfoManager(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class MultDoubleLinear(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeFunction(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Clamp(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class UvChooser(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DefaultRenderUtilityList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Mute(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The mute command is used to disable and enable playback on a channel. When a
        channel is muted, it retains the value that it was at prior to being muted.
        
        Flags:
        - disable : d                    (bool)          [create]
            Disable muting on the channels
        
        - force : f                      (bool)          [create]
            Forceable disable of muting on the channels. If there are keys on the mute
            channel, the animation and mute node will both be removed.  If this flag is not
            set, then mute nodes with animation will only be disabled.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.mute`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DataBlockTest(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeToUnitConversion(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderQuality(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ShapeEditorManager(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimClip(DependNode):
    def getAbsoluteChannelSettings(self):
        """
        Return an array indicating which channels of the clip are absolute and which are relative. The length of the array is equal to the members in the character. A value of one in the array indicates absolute and a value of 0 indicates relative.
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getAbsoluteChannelSettings`
        """
        pass
    def getEnabled(self):
        """
        Return the value of this clip's enable attribute
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getEnabled`
        """
        pass
    def getMemberAnimCurves(self):
        """
        Return two arrays: the first contains the animCurves associated with this clip. The second contains the character member that is driven by this animCurve.
        
        Returns:
        Tuple[List['PyNode'], List['PyNode']]
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getMemberAnimCurves`
        """
        pass
    def getPostCycle(self):
        """
        Return the value of this clip's post cycle attribute
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getPostCycle`
        """
        pass
    def getPreCycle(self):
        """
        Return the value of this clip's pre cycle attribute
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getPreCycle`
        """
        pass
    def getScale(self):
        """
        Return the value of this clip's scale attribute
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getScale`
        """
        pass
    def getSourceDuration(self):
        """
        Return the value of the start frame of this clip's source duration. The sourceStart and sourceDuration define the region of the animCurve that is treated as the clip.
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getSourceDuration`
        """
        pass
    def getSourceStart(self):
        """
        Return the value of the start frame of this clip's source clip. The sourceStart and sourceDuration define the region of the animCurve that is treated as the clip.
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getSourceStart`
        """
        pass
    def getStartFrame(self):
        """
        Return the value of this clip's start frame
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getStartFrame`
        """
        pass
    def getWeight(self):
        """
        Return the value of this clip's weight attribute
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.getWeight`
        """
        pass
    def isInstancedClip(self):
        """
        Return true or false as to whether the clip node represents the source clip or an instanced clip. All clips maintained by the clipScheduler node and visible in the TraX editor are instanced clips. All clips maintained by the clipLibrary node and visible in the Visor are non-instanced clips, also called "Source Clips". Each instanced clip has a corresponding source clip.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.isInstancedClip`
        """
        pass
    def isPose(self):
        """
        Return true or false as to whether the clip node represents a pose.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.isPose`
        """
        pass
    def setAbsoluteChannelSettings(self, absoluteChannels, mod='None'):
        """
        Set which channels of the clip are absolute and which are relative. The length of the specified array should be equal to the number of members in the character. A value of one in the array indicates absolute and a value of 0 indicates relative.
        
        Parameters:
        absoluteChannels : List['int']
            array containing the absolute channels to be set
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setAbsoluteChannelSettings`
        """
        pass
    def setEnabled(self, val, mod='None'):
        """
        Specify whether or not the clip is enabled. Note: should not be called for source clips since the enabled attribute is ignored on source clips.
        
        Parameters:
        val : 'bool'
            enable value
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setEnabled`
        """
        pass
    def setPoseClip(self, state, mod='None'):
        """
        Specify whether or not this clip node should be tagged as a pose rather than a clip. By default, clip nodes are not poses.
        
        Parameters:
        state : 'bool'
            true, to tag the clip as a pose
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setPoseClip`
        """
        pass
    def setPostCycle(self, cycle, mod='None'):
        """
        Specify the post cycle value for the clip.
        
        Parameters:
        cycle : 'float'
            cycle value
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setPostCycle`
        """
        pass
    def setPreCycle(self, cycle, mod='None'):
        """
        Specify the pre cycle value for the clip.
        
        Parameters:
        cycle : 'float'
            cycle value
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setPreCycle`
        """
        pass
    def setScale(self, scale, mod='None'):
        """
        Specify a scale value for the clip.
        
        Parameters:
        scale : 'float'
            scale value
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setScale`
        """
        pass
    def setSourceData(self, start, duration, mod='None'):
        """
        Specify the start frame and duration for the source clip associated with this clip.
        
        Parameters:
        start : 'Time'
            source start frame value
        duration : 'Time'
            source duration value
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setSourceData`
        """
        pass
    def setStartFrame(self, start, mod='None'):
        """
        Specify the start frame for the instanced clip. Note: should not be called for source clips since the start frame attribute is ignored on source clips.
        
        Parameters:
        start : 'Time'
            start frame value
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setStartFrame`
        """
        pass
    def setWeight(self, wt, mod='None'):
        """
        Specify a weight value for the clip.
        
        Parameters:
        wt : 'float'
            weight value
        mod : 'MDGModifier'
            modifier to use when calling this method from commands that support undo
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.setWeight`
        """
        pass
    def sourceClip(self):
        """
        Return the source clip associated with the MFnClip's clip
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnClip.sourceClip`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CopyColorSet(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ClosestPointOnMesh(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class VolumeShader(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RemapColor(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Chooser(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class VectorRenderGlobals(DependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurve(DependNode):
    def addKeyTT(self, timeInput, timeValue, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given output time value and tangent types at the specified input time for curves of type kAnimCurveTT.
        
        Parameters:
        timeInput : 'Time'
            Time at which the key is to be added
        timeValue : 'Time'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def addKeyTU(self, time, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        time : 'Time'
            Time at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def addKeyUT(self, unitlessInput, timeValue, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given output time value and tangent types at the specified unitless input for curves of type kAnimCurveUT.
        
        Parameters:
        unitlessInput : 'float'
            Unitless input at which the key is to be added
        timeValue : 'Time'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def addKeyUU(self, unitlessInput, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified unitless input for curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU.
        
        Parameters:
        unitlessInput : 'float'
            Unitless input at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def addKeyframe(self, *args, **kwargs):
        """
        # because addKeyframe only works with TA/TL/TU, make it an alias for addKey
        """
        pass
    def addKeys(self, time, values, tangentInType="'linear'", tangentOutType="'linear'", unit='None', keepExistingKeys='False'): pass
    def addKeysWithTangents(self, timeArray, valueArray, tangentInType="'global_'", tangentOutType="'global_'", tangentInTypeArray='None', tangentOutTypeArray='None', tangentInXArray='None', tangentInYArray='None', tangentOutXArray='None', tangentOutYArray='None', tangentsLockedArray='None', weightsLockedArray='None', convertUnits='True', keepExistingKeys='False'):
        """
        Add a set of new keys with the given corresponding values and tangent types at the specified times. This method only works for Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        timeArray : List['Time']
            Times at which keys are to be added
        valueArray : List['float']
            Values to which the keys is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for all the added keys
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for all the added keys
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentInTypeArray : List['int']
            In tangent types for individual added keys
        tangentOutTypeArray : List['int']
            Out tangent types for individual added keys
        tangentInXArray : List['float']
            Absolute x value of the slope of in tangent
        tangentInYArray : List['float']
            Absolute y value of the slope of in tangent
        tangentOutXArray : List['float']
            Absolute x value of the slope of out tangent
        tangentOutYArray : List['float']
            Absolute y value of the slope of out tangent
        tangentsLockedArray : List['int']
            Lock or unlock the tangents
        weightsLockedArray : List['int']
            Lock or unlock the weights
        convertUnits : 'bool'
            Whether to convert to UI units before setting
        keepExistingKeys : 'bool'
            Specifies whether the new keys should be merged with existing keys, or if they should be cut prior to adding the new keys
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKeysWithTangents`
        """
        pass
    def animCurveType(self):
        """
        Returns the animCurve type
        
        Returns:
        'AnimCurve.AnimCurveType'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.animCurveType`
        """
        pass
    def evaluateTT(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTT at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def evaluateTU(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def evaluateUT(self, atUnitlessInput):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveUT at the specified unitless input.
        
        Returns:
        Tuple['float', 'Time']
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def evaluateUU(self, atUnitlessInput):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU at the specified unitless input.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosestT(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    def findClosestU(self, unitlessInput):
        """
        Determines the index of the key which is set at the time closest to the specified unitless input value.
        
        Parameters:
        unitlessInput : 'float'
            Input value for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    def getInTangentType(self, index):
        """
        Determines the type of the tangent to the curve entering the current key.
        
        Parameters:
        index : 'int'
            Index of the key for which the tangent type is required
        
        
        Returns:
        'AnimCurve.TangentType'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.inTangentType`
        """
        pass
    def getOutTangentType(self, index):
        """
        Determines the type of the tangent to the curve leaving the current key.
        
        Parameters:
        index : 'int'
            Index of the key for which the tangent type is required
        
        
        Returns:
        'AnimCurve.TangentType'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.outTangentType`
        """
        pass
    def getPostInfinityType(self):
        """
        Determines the behaviour of the curve for the range occurring after the last key.
        
        Returns:
        'AnimCurve.InfinityType'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.postInfinityType`
        """
        pass
    def getPreInfinityType(self):
        """
        Determines the behaviour of the curve for the range occurring before the first key.
        
        Returns:
        'AnimCurve.InfinityType'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.preInfinityType`
        """
        pass
    def getTangentsLocked(self, index):
        """
        Determines whether the tangents are locked at the given key.
        
        Parameters:
        index : 'int'
            Index of the key to check for locked tangents
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.tangentsLocked`
        """
        pass
    def getTime(self, index):
        """
        Determines the time of the key at the specified index.
        
        Parameters:
        index : 'int'
            Index of the key for which the time is required
        
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.time`
        """
        pass
    def getUnitlessInput(self, index):
        """
        Determines the unitless input value of the key at the specified index. This method should only be used on Anim Curves of type kAnimCurveU*.
        
        Parameters:
        index : 'int'
            Index of the key for which the input value is required
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.unitlessInput`
        """
        pass
    def getValue(self, index):
        """
        Determines the value of the key at the specified index. This method should only be used on Anim Curves of type kAnimCurve*A, kAnimCurve*L or kAnimCurve*U.
        
        Parameters:
        index : 'int'
            Index of the key for which the value is required
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.value`
        """
        pass
    def getWeightsLocked(self, index):
        """
        Determines whether the weights are locked at the given key.
        
        Parameters:
        index : 'int'
            Index of the key to check for locked weights
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.weightsLocked`
        """
        pass
    def insertKey(self, time, breakdown='False'):
        """
        Inserts a key at the specified time adjusting neighboring tangents to maintain curve shape. This method is the API equivalent to setKeyframe -insert.
        
        Parameters:
        time : 'Time'
            Time to insert the key
        breakdown : 'bool'
            Whether the new key is a breakdown key
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.insertKey`
        """
        pass
    def isBreakdown(self, index):
        """
        Determines whether or not a key is a breakdown.
        
        Parameters:
        index : 'int'
            The key's index
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.isBreakdown`
        """
        pass
    def isStatic(self):
        """
        Determines whether or not the animCurve is static. The animCurve is considered to be static if it would return the same value regardless of the evaluation time. This basically means that the values of all the keys are the same and the y component of all the tangents is 0.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.isStatic`
        """
        pass
    def isTimeInput(self):
        """
        Determines the input type of the animCurve.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.isTimeInput`
        """
        pass
    def isUnitlessInput(self):
        """
        Determines the input type of the animCurve.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.isUnitlessInput`
        """
        pass
    def isWeighted(self):
        """
        Determines whether or not the curve has weighted tangents.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.isWeighted`
        """
        pass
    def numKeyframes(self): pass
    def numKeys(self):
        """
        Determines the number of keys on the Anim Curve Node.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.numKeys`
        """
        pass
    def remove(self, index):
        """
        Removes the key at the specified index.
        
        Parameters:
        index : 'int'
            Index of the key to be removed
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.remove`
        """
        pass
    def setAngle(self, index, angle, inTangent):
        """
        Set the in- or out-angle of the tangent for the key at the given index
        
        Parameters:
        index : 'int'
            Index of the key
        angle : 'Angle'
            The new in- or out-angle for the key's tangent
        inTangent : 'bool'
            If true, set the in-tangent, else out-tangent
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setAngle`
        """
        pass
    def setBreakdown(self, index, isBreakdown):
        """
        Sets the breakdown state of a key at a given index.
        
        Parameters:
        index : 'int'
            Index of the key whose breakdown state is to be modified
        isBreakdown : 'bool'
            The new breakdown state for the key.
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setIsBreakdown`
        """
        pass
    def setInTangentType(self, index, tangentType):
        """
        Sets the type of the tangent to the curve entering the key at the specified index.
        
        Parameters:
        index : 'int'
            Index of the key for which the tangent type is to be set
        tangentType : 'AnimCurve.TangentType'
            Type to which the tangent is to be set
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setInTangentType`
        """
        pass
    def setOutTangentType(self, index, tangentType):
        """
        Sets the type of the tangent to the curve leaving the key at the specified index.
        
        Parameters:
        index : 'int'
            Index of the key for which the tangent type is to be set
        tangentType : 'AnimCurve.TangentType'
            Type to which the tangent is to be set
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setOutTangentType`
        """
        pass
    def setPostInfinityType(self, infinityType):
        """
        Set the behaviour of the curve for the range occurring after the last key.
        
        Parameters:
        infinityType : 'AnimCurve.InfinityType'
            The infinity type to be set.
        
            values: 'constant', 'linear', 'cycle', 'cycleRelative', 'oscillate'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setPostInfinityType`
        """
        pass
    def setPreInfinityType(self, infinityType):
        """
        Set the behaviour of the curve for the range occurring before the first key.
        
        Parameters:
        infinityType : 'AnimCurve.InfinityType'
            The infinity type to be set.
        
            values: 'constant', 'linear', 'cycle', 'cycleRelative', 'oscillate'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setPreInfinityType`
        """
        pass
    def setTangentTypes(self, indexArray, inTangentType="'global_'", outTangentType="'global_'"):
        """
        Sets the tangent types for multiple keys.
        
        Parameters:
        indexArray : List['int']
            Indices of the key for which the tangent type is to be set
        inTangentType : 'AnimCurve.TangentType'
            Type to which the in tangent is to be set
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        outTangentType : 'AnimCurve.TangentType'
            Type to which the out tangent is to be set
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setTangentTypes`
        """
        pass
    def setTangentsLocked(self, index, locked):
        """
        Lock or unlock the tangents at the given key.
        
        Parameters:
        index : 'int'
            Index of the key at which to set/unset the locks
        locked : 'bool'
            true if the tangents are to be locked, false otherwise
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setTangentsLocked`
        """
        pass
    def setTime(self, index, time):
        """
        Sets the time of the key at the specified index. This will fail if setting the time would require re-ordering of the keys. This method should only be used on Anim Curves of type kAnimCurveT*.
        
        Parameters:
        index : 'int'
            Index of the key for which the time is to be set
        time : 'Time'
            Time to which the indexed key time is to be set
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setTime`
        """
        pass
    def setUnitlessInput(self, index, unitlessInput):
        """
        Sets the value of the unitless input of the key at the specified index. This will fail if setting the value would require re-ordering of the keys. This method should only be used on Anim Curves of type kAnimCurveU*.
        
        Parameters:
        index : 'int'
            Index of the key for which the unitless input value is to be set
        unitlessInput : 'float'
            Value to which the indexed key unitless input value is to be set
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setUnitlessInput`
        """
        pass
    def setValue(self, index, value):
        """
        Sets the value of the key at the specified index. This method should only be used on Anim Curves of type kAnimCurve*A, kAnimCurve*L or kAnimCurve*U.
        
        Parameters:
        index : 'int'
            Index of the key for which the value is to be set
        value : 'float'
            Value to which the key is to be set
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setValue`
        """
        pass
    def setWeight(self, index, weight, inTangent):
        """
        Set the in- or out-weight of the tangent for the key at the given index
        
        Parameters:
        index : 'int'
            Index of the key
        weight : 'float'
            The new in- or out-weight for the key's tangent
        inTangent : 'bool'
            If true, set the in-tangent, else set out-tangent
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setWeight`
        """
        pass
    def setWeighted(self, isWeighted):
        """
        Sets whether or not the curve has weighted tangents.
        
        Parameters:
        isWeighted : 'bool'
            Whether or not the curve should have weighted tangents
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setIsWeighted`
        """
        pass
    def setWeightsLocked(self, index, locked):
        """
        Lock or unlock the weights at the given key.
        
        Parameters:
        index : 'int'
            Index of the key at which to set/unset the locks
        locked : 'bool'
            true if the weights are to be locked, false otherwise
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.setWeightsLocked`
        """
        pass
    @classmethod
    def timedAnimCurveTypeForPlug(cls, plug):
        """
        Returns the timed animCurve type appropriate for the specified plug.
        
        Parameters:
        plug : 'PyNode'
            plug
        
        
        Returns:
        'AnimCurve.AnimCurveType'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.timedAnimCurveTypeForPlug`
        """
        pass
    @classmethod
    def unitlessAnimCurveTypeForPlug(cls, plug):
        """
        Returns the unitless animCurve type appropriate for the specified plug.
        
        Parameters:
        plug : 'PyNode'
            plug
        
        
        Returns:
        'AnimCurve.AnimCurveType'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.unitlessAnimCurveTypeForPlug`
        """
        pass
    AnimCurveType = {}
    
    
    InfinityType = {}
    
    
    TangentType = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BlendColors(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CombinationShape(DependNode):
    def getAllDrivers(self, **kwargs):
        """
        All drivers of the combination shape                               
        
        
        Derived from mel command `maya.cmds.combinationShape`
        """
        pass
    def getCombineMethod(self, **kwargs):
        """
        Combine method of the combination shape: 0 : Multiplication1 : Lowest Weighting2 : Lowest Weighting (Smooth)
        
        
        Derived from mel command `maya.cmds.combinationShape`
        """
        pass
    def getExist(self, **kwargs):
        """
        If the combination shape exist                             
        
        
        Derived from mel command `maya.cmds.combinationShape`
        """
        pass
    def setCombineMethod(self, val='True', **kwargs):
        """
        Combine method of the combination shape: 0 : Multiplication1 : Lowest Weighting2 : Lowest Weighting (Smooth)
        
        
        Derived from mel command `maya.cmds.combinationShape`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command to create or edit drive relationship of blend shape targets
        
        Flags:
        - addDriver : add                (bool)          []
            Add drivers to the combination shape
        
        - allDrivers : ald               (bool)          [query]
            All drivers of the combination shape
        
        - blendShape : bs                (unicode)       [create]
            Associated blend shape node of the combination shape In query mode, this flag
            can accept a value.
        
        - combinationTargetIndex : cti   (int)           [create]
            Driven blend shape target index of the combination shape In query mode, this
            flag can accept a value.
        
        - combinationTargetName : ctn    (unicode)       [create]
            Driven blend shape target name of the combination shape In query mode, this flag
            can accept a value.
        
        - combineMethod : cm             (int)           [create,query,edit]
            Combine method of the combination shape: 0 : Multiplication1 : Lowest Weighting2
            : Lowest Weighting (Smooth)
        
        - driverTargetIndex : dti        (int)           [create]
            Driver blend shape target index of the combination shape
        
        - driverTargetName : dtn         (unicode)       [create]
            Driver blend shape target name of the combination shape
        
        - exist : ex                     (bool)          [query]
            If the combination shape exist
        
        - removeDriver : rmd             (bool)          []
            Remove drivers from the combination shape                                  Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.combinationShape`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ToonLineAttributes(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DynController(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Sequencer(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdBase(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DefaultShaderList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CopyUVSet(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DeleteComponent(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class THdependNode(DependNode):
    """
    # ------ Do not edit below this line --------
    """
    
    
    
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyBlindData(DependNode):
    def associationType(self, val='True', **kwargs):
        """
        Specifies the dataTypes that are part of BlindData node being created. Allowable associations are objectfor any object, and vertexedgeand facefor mesh objects. Other associations for other geometry types may be added.                                  
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def binaryData(self, val='True', **kwargs):
        """
        Specifies the data type is a binary data value                             
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def booleanData(self, val='True', **kwargs):
        """
        Specifies the data type is a boolean logic value                                   
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def delete(self, val='True', **kwargs):
        """
        Specifies that this will remove the blind data if found                                    
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def doubleData(self, val='True', **kwargs):
        """
        Specifies the data type is a floating point double value                                   
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def int64Data(self, val='True', **kwargs):
        """
        Specifies the data type is an 64-bit integer value                                 
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def intData(self, val='True', **kwargs):
        """
        Specifies the data type is an integer value                                
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def longDataName(self, val='True', **kwargs):
        """
        Specifies the long name of the data that is being modified by this command.                                
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def rescan(self, val='True', **kwargs):
        """
        Enables a rescan of blind data nodes for cached information                                
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def reset(self, val='True', **kwargs):
        """
        Specifies that this command will reset the given attribute to default value                                
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setTypeId(self, val='True', **kwargs):
        """
        Specifies the typeId of the BlindData type being created                                   Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def shape(self, val='True', **kwargs):
        """
        For object association only, apply blind data to the shape(s) below this node instead of the node itself                                   
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def shortDataName(self, val='True', **kwargs):
        """
        Specifies the short name of the data that is being modified by this command.                               
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    def stringData(self, val='True', **kwargs):
        """
        Specifies the data type is a string value                                  
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command creates blindData types (basically creates an instance of
        TdnPolyBlindData). When used with the query flag, it returns the data types that
        define this blindData type. This command is to be used create a blindData node
        \*and\* to edit the same.. The associationType flag \*has\* to be specified at
        all times.. This is because if an instance of the specified BD typeId exists in
        the history chain but if the associationType is not the same, then a new
        polyBlindData node is created.. For object level blind data, only the object
        itself must be specified. A new compound attribute BlindDataNNNN will be created
        on the object. Blind data attribute names must be unique across types for object
        level blind data. So, the command will require the following to be specified:
        - typeId,     - associationType     - longDataName or shortDataName of data
        being edited.     - The actual data being specified.     - The components that
        this data is to be attached to.
        
        Flags:
        - associationType : at           (unicode)       [create,edit]
            Specifies the dataTypes that are part of BlindData node being created. Allowable
            associations are objectfor any object, and vertexedgeand facefor mesh objects.
            Other associations for other geometry types may be added.
        
        - binaryData : bnd               (unicode)       [create,edit]
            Specifies the data type is a binary data value
        
        - booleanData : bd               (bool)          [create,edit]
            Specifies the data type is a boolean logic value
        
        - delete : delete                (bool)          [create,edit]
            Specifies that this will remove the blind data if found
        
        - doubleData : dbd               (float)         [create,edit]
            Specifies the data type is a floating point double value
        
        - int64Data : lid                (int)           [create,edit]
            Specifies the data type is an 64-bit integer value
        
        - intData : ind                  (int)           [create,edit]
            Specifies the data type is an integer value
        
        - longDataName : ldn             (unicode)       [create,edit]
            Specifies the long name of the data that is being modified by this command.
        
        - rescan : res                   (bool)          [create,edit]
            Enables a rescan of blind data nodes for cached information
        
        - reset : rst                    (bool)          [create,edit]
            Specifies that this command will reset the given attribute to default value
        
        - shape : sh                     (bool)          [create,edit]
            For object association only, apply blind data to the shape(s) below this node
            instead of the node itself
        
        - shortDataName : sdn            (unicode)       [create,edit]
            Specifies the short name of the data that is being modified by this command.
        
        - stringData : sd                (unicode)       [create,edit]
            Specifies the data type is a string value
        
        - typeId : id                    (int)           [create,edit]
            Specifies the typeId of the BlindData type being created
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyBlindData`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Time(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DeleteColorSet(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class OldBlindDataBase(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorProfile(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SurfaceLuminance(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySeparate(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySeparate`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySeparate`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySeparate`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySeparate`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates new objects from the given poly. A new object will be
        created for each section of the mesh that is distinct (no edges connect it to
        the rest of the mesh). This command can only separate one object at a time.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          []
        
        - endFace : ef                   (int)           []
        
        - frozen : fzn                   (bool)          []
        
        - inPlace : inp                  (bool)          []
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          []
        
        - removeShells : rs              (bool)          [create]
            Remove the shells after creation.
        
        - separateSpecificShell : sss    (int)           [create]
            List of shell ids to be separated.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - startFace : sf                 (int)           []
        
        - userSpecifiedShells : uss      (bool)          []
        
        
        Derived from mel command `maya.cmds.polySeparate`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GroupParts(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Derived from mel command `maya.cmds.groupParts`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveNormalizer(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class HyperGraphInfo(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DefaultRenderingList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DisplacementShader(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AboutToSetValueTestNode(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class ArrayMapper(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create an arrayMapper node and connect it to a target object. If the -type flag
        is used, then this command also creates an external node used for computing the
        output values. If the input attribute does not already exist, it will be
        created. The output attribute must exists. If    a flag is omitted, the
        selection list will be used to supply the needed objects. If none are found,
        that action is omitted.
        
        Flags:
        - destAttr : da                  (unicode)       [create]
            Specifies the attribute which will be the downstream connection for the output
            data from the mapper node. The attribute type will be used to determine which
            output attribute to use: float array gets outValuePP, vector array gets
            outColorPP. If the flag is omitted, no output connection is made.
        
        - inputU : iu                    (unicode)       [create]
            Specifies the upstream attribute to connect to the mapper's uCoordPP attribute.
            If the flag is omitted, no input connection is made.
        
        - inputV : iv                    (unicode)       [create]
            Specifies the upstream attribute to connect to the mapper's vCoordPP attribute.
            If the flag is omitted, no input connection is made.
        
        - mapTo : mt                     (unicode)       [create]
            Specifies an existing node to be used to compute the output values. This node
            must be of the appropriate type. Currently, only ramp nodes may be used.
        
        - target : t                     (unicode)       [create]
            Specifies the target object to be connected to.
        
        - type : ty                      (unicode)       [create]
            Specifies the node type to create which will be used to compute the output
            values. Currently, only ramp is valid. If the flag is omitted, no connection is
            made and the external node is not created.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.arrayMapper`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MultMatrix(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DisplayLayerManager(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyToSubdiv(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAbsolutePosition(self, **kwargs):
        """
        If true, the possible blind data information that comes from the polygon will be treated as absolute positions of the vertices, instead of the relative offsets.  You most likelly just want to use the default of false, unless you know that the blind data has the absolute positions in it. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getApplyMatrixToResult(self, **kwargs):
        """
        If true, the matrix on the input geometry is applied to the object and the resulting geometry will have identity matrix on it.  If false the conversion is done on the local space object and the resulting geometry has the input object's matrix on it. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getMaxEdgesPerVert(self, **kwargs):
        """
        The maximum allowed valence for a vertex on the input mesh Default:32                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getMaxPolyCount(self, **kwargs):
        """
        The maximum number of polygons accepted on the input mesh. Default:1000                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getPreserveVertexOrdering(self, **kwargs):
        """
        Preserve vertex ordering in conversion Default:true                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getQuickConvert(self, **kwargs):
        """
        Debug flag to test the performance Default:true                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getUvPoints(self, **kwargs):
        """
        This is a cached uv point needed to transfer uv data associated with finer level vertices (when switching between standard editing mode and poly proxy mode.                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getUvPointsU(self, **kwargs):
        """
        U value of a cached uv point                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getUvPointsV(self, **kwargs):
        """
        V value of a cached uv point                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def getUvTreatment(self, **kwargs):
        """
        Treatment of Subd UVs when in proxy mode: 0 - preserve Subd UVs1 - build Subd UVs from Poly UVs2 - no UVs on SubdDefault:0                  Common flags
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAbsolutePosition(self, val='True', **kwargs):
        """
        If true, the possible blind data information that comes from the polygon will be treated as absolute positions of the vertices, instead of the relative offsets.  You most likelly just want to use the default of false, unless you know that the blind data has the absolute positions in it. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setApplyMatrixToResult(self, val='True', **kwargs):
        """
        If true, the matrix on the input geometry is applied to the object and the resulting geometry will have identity matrix on it.  If false the conversion is done on the local space object and the resulting geometry has the input object's matrix on it. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setMaxEdgesPerVert(self, val='True', **kwargs):
        """
        The maximum allowed valence for a vertex on the input mesh Default:32                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setMaxPolyCount(self, val='True', **kwargs):
        """
        The maximum number of polygons accepted on the input mesh. Default:1000                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setPreserveVertexOrdering(self, val='True', **kwargs):
        """
        Preserve vertex ordering in conversion Default:true                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setQuickConvert(self, val='True', **kwargs):
        """
        Debug flag to test the performance Default:true                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setUvPoints(self, val='True', **kwargs):
        """
        This is a cached uv point needed to transfer uv data associated with finer level vertices (when switching between standard editing mode and poly proxy mode.                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setUvPointsU(self, val='True', **kwargs):
        """
        U value of a cached uv point                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setUvPointsV(self, val='True', **kwargs):
        """
        V value of a cached uv point                  
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    def setUvTreatment(self, val='True', **kwargs):
        """
        Treatment of Subd UVs when in proxy mode: 0 - preserve Subd UVs1 - build Subd UVs from Poly UVs2 - no UVs on SubdDefault:0                  Common flags
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command converts a polygon and produces a subd surface. The name of the new
        subdivision surface is returned. If construction history is ON, then the name of
        the new dependency node is returned as well.
        
        Flags:
        - absolutePosition : ap          (bool)          [create,query,edit]
            If true, the possible blind data information that comes from the polygon will be
            treated as absolute positions of the vertices, instead of the relative offsets.
            You most likelly just want to use the default of false, unless you know that the
            blind data has the absolute positions in it. Default:false
        
        - addUnderTransform : aut        (bool)          [create]
            If true then add the new subdivision surface under the poly's transform.
        
        - applyMatrixToResult : amr      (bool)          [create,query,edit]
            If true, the matrix on the input geometry is applied to the object and the
            resulting geometry will have identity matrix on it.  If false the conversion is
            done on the local space object and the resulting geometry has the input object's
            matrix on it. Default:true
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - maxEdgesPerVert : me           (int)           [create,query,edit]
            The maximum allowed valence for a vertex on the input mesh Default:32
        
        - maxPolyCount : mpc             (int)           [create,query,edit]
            The maximum number of polygons accepted on the input mesh. Default:1000
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - preserveVertexOrdering : pvo   (bool)          [create,query,edit]
            Preserve vertex ordering in conversion Default:true
        
        - quickConvert : qc              (bool)          [create,query,edit]
            Debug flag to test the performance Default:true
        
        - uvPoints : uvp                 (float, float)  [create,query,edit]
            This is a cached uv point needed to transfer uv data associated with finer level
            vertices (when switching between standard editing mode and poly proxy mode.
        
        - uvPointsU : uvu                (float)         [create,query,edit]
            U value of a cached uv point
        
        - uvPointsV : uvv                (float)         [create,query,edit]
            V value of a cached uv point
        
        - uvTreatment : uvt              (int)           [create,query,edit]
            Treatment of Subd UVs when in proxy mode: 0 - preserve Subd UVs1 - build Subd
            UVs from Poly UVs2 - no UVs on SubdDefault:0                  Common flags
        
        
        Derived from mel command `maya.cmds.polyToSubdiv`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HwReflectionMap(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getBackTextureName(self, **kwargs):
        """
        This flag specifies the file texture name for the back side of the cube.Default is noneWhen queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getBottomTextureName(self, **kwargs):
        """
        This flag specifies the file texture name for the bottom side of the cube.Default is noneWhen queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getCubeMap(self, **kwargs):
        """
        If on, the reflection of the textures is done using the cube mapping.Default is false. The reflection is done using sphere mapping.When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getDecalMode(self, **kwargs):
        """
        If on, the reflection color replaces the surface shading.Default is false. The reflection is multiplied to the surface shading.When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getEnable(self, **kwargs):
        """
        If on, enable the corresponding hwReflectionMap node.Default is false.When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getFrontTextureName(self, **kwargs):
        """
        This flag specifies the file texture name for the front side of the cube.Default is noneWhen queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getLeftTextureName(self, **kwargs):
        """
        This flag specifies the file texture name for the left side of the cube.Default is noneWhen queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getRightTextureName(self, **kwargs):
        """
        This flag specifies the file texture name for the right side of the cube.Default is noneWhen queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getSphereMapTextureName(self, **kwargs):
        """
        This flag specifies the file texture name for the sphere mapping option.Default is noneWhen queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def getTopTextureName(self, **kwargs):
        """
        This flag specifies the file texture name for the top side of the cube.Default is noneWhen queried, this flag returns a string.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a hwReflectionMap node for having reflection on textured
        surfaces that currently have their boolean attribute displayHWEnvironment set to
        true.
        
        Flags:
        - backTextureName : bkn          (unicode)       [query]
            This flag specifies the file texture name for the back side of the cube.Default
            is noneWhen queried, this flag returns a string.
        
        - bottomTextureName : bmn        (unicode)       [query]
            This flag specifies the file texture name for the bottom side of the
            cube.Default is noneWhen queried, this flag returns a string.
        
        - cubeMap : cm                   (bool)          [query]
            If on, the reflection of the textures is done using the cube mapping.Default is
            false. The reflection is done using sphere mapping.When queried, this flag
            returns a boolean.
        
        - decalMode : dm                 (bool)          [query]
            If on, the reflection color replaces the surface shading.Default is false. The
            reflection is multiplied to the surface shading.When queried, this flag returns
            a boolean.
        
        - enable : en                    (bool)          [query]
            If on, enable the corresponding hwReflectionMap node.Default is false.When
            queried, this flag returns a boolean.
        
        - frontTextureName : ftn         (unicode)       [query]
            This flag specifies the file texture name for the front side of the cube.Default
            is noneWhen queried, this flag returns a string.
        
        - leftTextureName : ltn          (unicode)       [query]
            This flag specifies the file texture name for the left side of the cube.Default
            is noneWhen queried, this flag returns a string.
        
        - rightTextureName : rtn         (unicode)       [query]
            This flag specifies the file texture name for the right side of the cube.Default
            is noneWhen queried, this flag returns a string.
        
        - sphereMapTextureName : smn     (unicode)       [query]
            This flag specifies the file texture name for the sphere mapping option.Default
            is noneWhen queried, this flag returns a string.
        
        - topTextureName : tpn           (unicode)       [query]
            This flag specifies the file texture name for the top side of the cube.Default
            is noneWhen queried, this flag returns a string.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.hwReflectionMap`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DeleteUVSet(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AddDoubleLinear(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class IkSolver(DependNode):
    def getEpsilon(self, **kwargs):
        """
        max error                  
        
        
        Derived from mel command `maya.cmds.ikSolver`
        """
        pass
    def getMaxIterations(self):
        """
        Returns the maximum number of iterations used when solving.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkSolver.maxIterations`
        """
        pass
    def getSolverType(self, **kwargs):
        """
        valid solverType (only ikSystem knows what is valid) for creation of a new solver (required)                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.ikSolver`
        """
        pass
    def getTolerance(self):
        """
        Returns the tolerance used when solving.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkSolver.tolerance`
        """
        pass
    def setEpsilon(self, val='True', **kwargs):
        """
        max error                  
        
        
        Derived from mel command `maya.cmds.ikSolver`
        """
        pass
    def setMaxIterations(self, maxIters):
        """
        Sets the maximum number of iterations used when solving.
        
        Parameters:
        maxIters : 'int'
            the new value for the maximum number of iterations for the solver
        
        Derived from api method `maya.OpenMayaAnim.MFnIkSolver.setMaxIterations`
        """
        pass
    def setSolverType(self, val='True', **kwargs):
        """
        valid solverType (only ikSystem knows what is valid) for creation of a new solver (required)                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.ikSolver`
        """
        pass
    def setTolerance(self, tolerance):
        """
        Sets the tolerance used when solving.
        
        Parameters:
        tolerance : 'float'
            The tolerance value to be set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkSolver.setTolerance`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The ikSolver command is used to set the attributes for an IK Solver or create a
        new one. The standard edit (-e) and query (-q) flags are used for edit and query
        functions.
        
        Flags:
        - epsilon : ep                   (float)         [create,query,edit]
            max error
        
        - maxIterations : mxi            (int)           [create,query,edit]
            Sets the max iterations for a solution
        
        - name : n                       (unicode)       [create,query,edit]
            Name of solver
        
        - solverType : st                (unicode)       [create,query,edit]
            valid solverType (only ikSystem knows what is valid) for creation of a new
            solver (required)                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.ikSolver`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AttrHierarchyTest(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class MaterialInfo(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Dof(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class IkSystem(DependNode):
    def autoPriority(self, val='True', **kwargs):
        """
        set autoPriority for all ikHandles                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def autoPriorityMC(self, val='True', **kwargs):
        """
        set autoPriority for all multiChain handles                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def autoPrioritySC(self, val='True', **kwargs):
        """
        set autoPriority for all singleChain handles                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getAllowRotation(self, **kwargs):
        """
        Set true to allow rotation of an ik handle with keys set on translation.                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getList(self, **kwargs):
        """
        returns the solver execution order when in query mode(list of strings) changes execution order when in edit mode (int old position, int new position)                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def getSnap(self, **kwargs):
        """
        Set global snapping                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def getSolve(self, **kwargs):
        """
        Set global solve                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def getSolverTypes(self, **kwargs):
        """
        returns a list of valid solverTypes ( query only )                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setAllowRotation(self, val='True', **kwargs):
        """
        Set true to allow rotation of an ik handle with keys set on translation.                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def setList(self, val='True', **kwargs):
        """
        returns the solver execution order when in query mode(list of strings) changes execution order when in edit mode (int old position, int new position)                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def setSnap(self, val='True', **kwargs):
        """
        Set global snapping                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    def setSolve(self, val='True', **kwargs):
        """
        Set global solve                  
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The ikSystem command is used to set the global snapping flag for handles and set
        the global solve flag for solvers.  The standard edit (-e) and query (-q) flags
        are used for edit and query functions.
        
        Flags:
        - allowRotation : ar             (bool)          [query,edit]
            Set true to allow rotation of an ik handle with keys set on translation.
        
        - autoPriority : ap              (bool)          [edit]
            set autoPriority for all ikHandles
        
        - autoPriorityMC : apm           (bool)          [edit]
            set autoPriority for all multiChain handles
        
        - autoPrioritySC : aps           (bool)          [edit]
            set autoPriority for all singleChain handles
        
        - list : ls                      (int, int)      [query,edit]
            returns the solver execution order when in query mode(list of strings) changes
            execution order when in edit mode (int old position, int new position)
        
        - snap : sn                      (bool)          [query,edit]
            Set global snapping
        
        - solve : sol                    (bool)          [query,edit]
            Set global solve
        
        - solverTypes : st               (bool)          [query]
            returns a list of valid solverTypes ( query only )                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.ikSystem`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ContainerBase(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class Resolution(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeGroup(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Audio(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CompactPlugArrayTest(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class StrokeGlobals(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class MultilisterLight(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class OldGeometryConstraint(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorManagementGlobals(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class ReorderUVSet(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class GroupId(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class FourByFourMatrix(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Shot(DependNode):
    def createCustomAnim(self, val='True', **kwargs):
        """
        Creates an animation layer and links the shot node's customAnim attr to the weight attr of the animation layer                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def deleteCustomAnim(self, val='True', **kwargs):
        """
        Disconnects the animation layer from this shot's customAnim attr and deletes the animation layer node                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getAudio(self, **kwargs):
        """
        Specify the audio clip for this shot. Audio can be linked to a shot to allow playback of specific sounds when that shot is being displayed in the Sequencer. Refer to the shot node's documentation for details on how audio is used by shots and the Sequencer.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getClip(self, **kwargs):
        """
        The clip associated with this shot. This clip will be posted to the currentCamera's imagePlane. Refer to the shot node's documentation for details on how cameras are used by shots and the Sequencer.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getClipDuration(self, **kwargs):
        """
        Length of clip. This is used for the display of the clip indicator bar in the Sequencer.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getClipOpacity(self, **kwargs):
        """
        Opacity for the shot's clip, this value is assigned to the currentCamera's imagePlane. Refer to the shot node's documentation for details on how cameras are used by shots and the Sequencer.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getClipSyncState(self, **kwargs):
        """
        The viewport synchronization status of the clip associated with this shot. Return values are, 0 = no clip associated with this shot 1 = clip is fully in sync with viewport, and frames are 1:1 with sequencer 2 = clip is partially in sync with viewport, movie may be scaled to match sequencer 3 = clip not in sync with viewport (i.e. could have scale/time/camera differences)                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getClipZeroOffset(self, **kwargs):
        """
        Specify which time of the clip corresponds to the beginning of the shot. This is used to properly align splitted clips.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getCopy(self, **kwargs):
        """
        This flag is used to copy a shot to the clipboard. In query mode, this flag allows you to query what, if anything, has been copied into the shot clipboard.                                
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getCurrentCamera(self, **kwargs):
        """
        The camera associated with this shot. Refer to the shot node's documentation for details on how cameras are used by shots and the Sequencer.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getCustomAnim(self, **kwargs):
        """
        Returns the name of the animation layer node linked to this shot node's customAnim attr                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getDetermineTrack(self, **kwargs):
        """
        Determines an available track for the shot. Returns a new track number or the existing track number if the current track is available.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getEndTime(self, **kwargs):
        """
        The shot end time in the Maya timeline. Changing the startTime will extend the duration of a shot.                                 
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFavorite(self, **kwargs):
        """
        Make the shot a favorite. This is a UI indicator only to streamline navigation in the Sequencer panel                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag1(self, **kwargs):
        """
        User specified state flag 1/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag10(self, **kwargs):
        """
        User specified state flag 10/12 for this shot                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag11(self, **kwargs):
        """
        User specified state flag 11/12 for this shot                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag12(self, **kwargs):
        """
        User specified state flag 12/12 for this shot                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag2(self, **kwargs):
        """
        User specified state flag 2/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag3(self, **kwargs):
        """
        User specified state flag 3/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag4(self, **kwargs):
        """
        User specified state flag 4/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag5(self, **kwargs):
        """
        User specified state flag 5/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag6(self, **kwargs):
        """
        User specified state flag 6/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag7(self, **kwargs):
        """
        User specified state flag 7/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag8(self, **kwargs):
        """
        User specified state flag 8/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getFlag9(self, **kwargs):
        """
        User specified state flag 9/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getHasCameraSet(self, **kwargs):
        """
        Returns true if the camera associated with this shot is a camera set.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getHasStereoCamera(self, **kwargs):
        """
        Returns true if the camera associated with this shot is a stereo camera.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getImagePlaneVisibility(self, **kwargs):
        """
        Visibility of the shot imageplane, this value is assigned to the currentCamera's imagePlane.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getLinkAudio(self, **kwargs):
        """
        Specify an audio clip to link to this shot. Any currently linked audio will be unlinked.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getLock(self, **kwargs):
        """
        Lock a specific shot. This is different than locking an entire track, which is done via the shotTrack command                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getMute(self, **kwargs):
        """
        Mute a specific shot. This is different than muting an entire track, which is done via the shotTrack command. Querying this attribute will return true if the shot is muted due to its own mute, its shot being muted, or its shot being unsoloed. See flag selfmuteto query only the shot's own state.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getPaste(self, **kwargs):
        """
        This flag is used to paste a shot or shots from the clipboard to the sequence timeline. Shots are added to the clipboard using the c/copy flag.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getPasteInstance(self, **kwargs):
        """
        This flag is used to paste an instance of a shot or shots from the clipboard to the sequence timeline. Unlike the p/paste flag, which duplicates the camera and image plane from the original source shot, the pi/pasteInstance flag shares the camera and image plane from the source shot. The audio node is duplicated.                                 
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getPostHoldTime(self, **kwargs):
        """
        Specify the time length to append to the shot in the sequence timeline. This repeats the last frame of the shot, in sequence time, over the specified duration.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getPreHoldTime(self, **kwargs):
        """
        Specify the time length to prepend to the shot in the sequence timeline. This repeats the first frame of the shot, in sequence time, over the specified duration.                                  
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getScale(self, **kwargs):
        """
        Specify an amount to scale the Maya frame range of the shot. This will affect the sequenceEndFrame, leaving the sequenceStartFrame unchanged.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getSelfmute(self, **kwargs):
        """
        Query if this individual shot's own mute state is set. This is different from the flag mute, which will return true if this shot is muted due to the track being muted or another track being soloed. Editing this flag will set this shot's own mute status (identical behavior as the flag mute).                                
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getSequenceDuration(self, **kwargs):
        """
        Return the sequence duration of the shot, which will include the holds and scale. This flag can only be queried.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getSequenceEndTime(self, **kwargs):
        """
        The shot end in the sequence timeline. Changing the endTime of a shot will scale it in sequence time.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getSequenceStartTime(self, **kwargs):
        """
        The shot start in the sequence timeline. Changing the startTime of a shot will shift it in sequence time.                                  
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getShotName(self, **kwargs):
        """
        Specify a user-defined name for this shot. This allows the assignment of names that are not valid as node names within Maya. Whenever the shotName attribute is defined its value is used in the UI.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getSourceDuration(self, **kwargs):
        """
        Return the number of source frames in the shot. This flag can only be queried.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getStartTime(self, **kwargs):
        """
        The shot start time in the Maya timeline. Changing the startTime will extend the duration of a shot.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getTrack(self, **kwargs):
        """
        Specify the track in which this shot resides.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getTransitionInLength(self, **kwargs):
        """
        Length of the transtion into the shot.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getTransitionInType(self, **kwargs):
        """
        Specify the the type of transition for the transition into the shot. 0 = Fade 1 = Dissolve                                 
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getTransitionOutLength(self, **kwargs):
        """
        Length of the transtion out of the shot.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getTransitionOutType(self, **kwargs):
        """
        Specify the the type of transition for the transition out of the shot. 0 = Fade 1 = Dissolve                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def getUnlinkAudio(self, **kwargs):
        """
        COMMENT Unlinks any currently linked audio.                                Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setAudio(self, val='True', **kwargs):
        """
        Specify the audio clip for this shot. Audio can be linked to a shot to allow playback of specific sounds when that shot is being displayed in the Sequencer. Refer to the shot node's documentation for details on how audio is used by shots and the Sequencer.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setClip(self, val='True', **kwargs):
        """
        The clip associated with this shot. This clip will be posted to the currentCamera's imagePlane. Refer to the shot node's documentation for details on how cameras are used by shots and the Sequencer.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setClipDuration(self, val='True', **kwargs):
        """
        Length of clip. This is used for the display of the clip indicator bar in the Sequencer.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setClipOpacity(self, val='True', **kwargs):
        """
        Opacity for the shot's clip, this value is assigned to the currentCamera's imagePlane. Refer to the shot node's documentation for details on how cameras are used by shots and the Sequencer.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setClipSyncState(self, val='True', **kwargs):
        """
        The viewport synchronization status of the clip associated with this shot. Return values are, 0 = no clip associated with this shot 1 = clip is fully in sync with viewport, and frames are 1:1 with sequencer 2 = clip is partially in sync with viewport, movie may be scaled to match sequencer 3 = clip not in sync with viewport (i.e. could have scale/time/camera differences)                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setClipZeroOffset(self, val='True', **kwargs):
        """
        Specify which time of the clip corresponds to the beginning of the shot. This is used to properly align splitted clips.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setCopy(self, val='True', **kwargs):
        """
        This flag is used to copy a shot to the clipboard. In query mode, this flag allows you to query what, if anything, has been copied into the shot clipboard.                                
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setCurrentCamera(self, val='True', **kwargs):
        """
        The camera associated with this shot. Refer to the shot node's documentation for details on how cameras are used by shots and the Sequencer.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setDetermineTrack(self, val='True', **kwargs):
        """
        Determines an available track for the shot. Returns a new track number or the existing track number if the current track is available.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setEndTime(self, val='True', **kwargs):
        """
        The shot end time in the Maya timeline. Changing the startTime will extend the duration of a shot.                                 
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFavorite(self, val='True', **kwargs):
        """
        Make the shot a favorite. This is a UI indicator only to streamline navigation in the Sequencer panel                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag1(self, val='True', **kwargs):
        """
        User specified state flag 1/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag10(self, val='True', **kwargs):
        """
        User specified state flag 10/12 for this shot                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag11(self, val='True', **kwargs):
        """
        User specified state flag 11/12 for this shot                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag12(self, val='True', **kwargs):
        """
        User specified state flag 12/12 for this shot                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag2(self, val='True', **kwargs):
        """
        User specified state flag 2/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag3(self, val='True', **kwargs):
        """
        User specified state flag 3/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag4(self, val='True', **kwargs):
        """
        User specified state flag 4/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag5(self, val='True', **kwargs):
        """
        User specified state flag 5/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag6(self, val='True', **kwargs):
        """
        User specified state flag 6/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag7(self, val='True', **kwargs):
        """
        User specified state flag 7/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag8(self, val='True', **kwargs):
        """
        User specified state flag 8/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setFlag9(self, val='True', **kwargs):
        """
        User specified state flag 9/12 for this shot                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setHasCameraSet(self, val='True', **kwargs):
        """
        Returns true if the camera associated with this shot is a camera set.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setHasStereoCamera(self, val='True', **kwargs):
        """
        Returns true if the camera associated with this shot is a stereo camera.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setImagePlaneVisibility(self, val='True', **kwargs):
        """
        Visibility of the shot imageplane, this value is assigned to the currentCamera's imagePlane.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setLinkAudio(self, val='True', **kwargs):
        """
        Specify an audio clip to link to this shot. Any currently linked audio will be unlinked.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setLock(self, val='True', **kwargs):
        """
        Lock a specific shot. This is different than locking an entire track, which is done via the shotTrack command                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setMute(self, val='True', **kwargs):
        """
        Mute a specific shot. This is different than muting an entire track, which is done via the shotTrack command. Querying this attribute will return true if the shot is muted due to its own mute, its shot being muted, or its shot being unsoloed. See flag selfmuteto query only the shot's own state.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setPaste(self, val='True', **kwargs):
        """
        This flag is used to paste a shot or shots from the clipboard to the sequence timeline. Shots are added to the clipboard using the c/copy flag.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setPasteInstance(self, val='True', **kwargs):
        """
        This flag is used to paste an instance of a shot or shots from the clipboard to the sequence timeline. Unlike the p/paste flag, which duplicates the camera and image plane from the original source shot, the pi/pasteInstance flag shares the camera and image plane from the source shot. The audio node is duplicated.                                 
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setPostHoldTime(self, val='True', **kwargs):
        """
        Specify the time length to append to the shot in the sequence timeline. This repeats the last frame of the shot, in sequence time, over the specified duration.                                    
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setPreHoldTime(self, val='True', **kwargs):
        """
        Specify the time length to prepend to the shot in the sequence timeline. This repeats the first frame of the shot, in sequence time, over the specified duration.                                  
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        Specify an amount to scale the Maya frame range of the shot. This will affect the sequenceEndFrame, leaving the sequenceStartFrame unchanged.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setSelfmute(self, val='True', **kwargs):
        """
        Query if this individual shot's own mute state is set. This is different from the flag mute, which will return true if this shot is muted due to the track being muted or another track being soloed. Editing this flag will set this shot's own mute status (identical behavior as the flag mute).                                
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setSequenceDuration(self, val='True', **kwargs):
        """
        Return the sequence duration of the shot, which will include the holds and scale. This flag can only be queried.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setSequenceEndTime(self, val='True', **kwargs):
        """
        The shot end in the sequence timeline. Changing the endTime of a shot will scale it in sequence time.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setSequenceStartTime(self, val='True', **kwargs):
        """
        The shot start in the sequence timeline. Changing the startTime of a shot will shift it in sequence time.                                  
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setShotName(self, val='True', **kwargs):
        """
        Specify a user-defined name for this shot. This allows the assignment of names that are not valid as node names within Maya. Whenever the shotName attribute is defined its value is used in the UI.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setSourceDuration(self, val='True', **kwargs):
        """
        Return the number of source frames in the shot. This flag can only be queried.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setStartTime(self, val='True', **kwargs):
        """
        The shot start time in the Maya timeline. Changing the startTime will extend the duration of a shot.                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setTrack(self, val='True', **kwargs):
        """
        Specify the track in which this shot resides.                              
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setTransitionInLength(self, val='True', **kwargs):
        """
        Length of the transtion into the shot.                             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setTransitionInType(self, val='True', **kwargs):
        """
        Specify the the type of transition for the transition into the shot. 0 = Fade 1 = Dissolve                                 
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setTransitionOutLength(self, val='True', **kwargs):
        """
        Length of the transtion out of the shot.                                   
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setTransitionOutType(self, val='True', **kwargs):
        """
        Specify the the type of transition for the transition out of the shot. 0 = Fade 1 = Dissolve                               
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    def setUnlinkAudio(self, val='True', **kwargs):
        """
        COMMENT Unlinks any currently linked audio.                                Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Use this command to create a shot node or manipulate that node.
        
        Flags:
        - audio : aud                    (unicode)       [create,query,edit]
            Specify the audio clip for this shot. Audio can be linked to a shot to allow
            playback of specific sounds when that shot is being displayed in the Sequencer.
            Refer to the shot node's documentation for details on how audio is used by shots
            and the Sequencer.
        
        - clip : cl                      (unicode)       [create,query,edit]
            The clip associated with this shot. This clip will be posted to the
            currentCamera's imagePlane. Refer to the shot node's documentation for details
            on how cameras are used by shots and the Sequencer.
        
        - clipDuration : cd              (time)          [create,query,edit]
            Length of clip. This is used for the display of the clip indicator bar in the
            Sequencer.
        
        - clipOpacity : co               (float)         [create,query,edit]
            Opacity for the shot's clip, this value is assigned to the currentCamera's
            imagePlane. Refer to the shot node's documentation for details on how cameras
            are used by shots and the Sequencer.
        
        - clipSyncState : css            (bool)          [create,query,edit]
            The viewport synchronization status of the clip associated with this shot.
            Return values are, 0 = no clip associated with this shot 1 = clip is fully in
            sync with viewport, and frames are 1:1 with sequencer 2 = clip is partially in
            sync with viewport, movie may be scaled to match sequencer 3 = clip not in sync
            with viewport (i.e. could have scale/time/camera differences)
        
        - clipZeroOffset : czo           (time)          [create,query,edit]
            Specify which time of the clip corresponds to the beginning of the shot. This is
            used to properly align splitted clips.
        
        - copy : c                       (bool)          [create,query,edit]
            This flag is used to copy a shot to the clipboard. In query mode, this flag
            allows you to query what, if anything, has been copied into the shot clipboard.
        
        - createCustomAnim : cca         (bool)          [edit]
            Creates an animation layer and links the shot node's customAnim attr to the
            weight attr of the animation layer
        
        - currentCamera : cc             (unicode)       [create,query,edit]
            The camera associated with this shot. Refer to the shot node's documentation for
            details on how cameras are used by shots and the Sequencer.
        
        - customAnim : ca                (bool)          [query]
            Returns the name of the animation layer node linked to this shot node's
            customAnim attr
        
        - deleteCustomAnim : dca         (bool)          [edit]
            Disconnects the animation layer from this shot's customAnim attr and deletes the
            animation layer node
        
        - determineTrack : dt            (bool)          [query,edit]
            Determines an available track for the shot. Returns a new track number or the
            existing track number if the current track is available.
        
        - endTime : et                   (time)          [create,query,edit]
            The shot end time in the Maya timeline. Changing the startTime will extend the
            duration of a shot.
        
        - favorite : fav                 (bool)          [create,query,edit]
            Make the shot a favorite. This is a UI indicator only to streamline navigation
            in the Sequencer panel
        
        - flag1 : f1                     (bool)          [create,query,edit]
            User specified state flag 1/12 for this shot
        
        - flag10 : f10                   (bool)          [create,query,edit]
            User specified state flag 10/12 for this shot
        
        - flag11 : f11                   (bool)          [create,query,edit]
            User specified state flag 11/12 for this shot
        
        - flag12 : f12                   (bool)          [create,query,edit]
            User specified state flag 12/12 for this shot
        
        - flag2 : f2                     (bool)          [create,query,edit]
            User specified state flag 2/12 for this shot
        
        - flag3 : f3                     (bool)          [create,query,edit]
            User specified state flag 3/12 for this shot
        
        - flag4 : f4                     (bool)          [create,query,edit]
            User specified state flag 4/12 for this shot
        
        - flag5 : f5                     (bool)          [create,query,edit]
            User specified state flag 5/12 for this shot
        
        - flag6 : f6                     (bool)          [create,query,edit]
            User specified state flag 6/12 for this shot
        
        - flag7 : f7                     (bool)          [create,query,edit]
            User specified state flag 7/12 for this shot
        
        - flag8 : f8                     (bool)          [create,query,edit]
            User specified state flag 8/12 for this shot
        
        - flag9 : f9                     (bool)          [create,query,edit]
            User specified state flag 9/12 for this shot
        
        - hasCameraSet : hcs             (bool)          [create,query,edit]
            Returns true if the camera associated with this shot is a camera set.
        
        - hasStereoCamera : hsc          (bool)          [create,query,edit]
            Returns true if the camera associated with this shot is a stereo camera.
        
        - imagePlaneVisibility : ipv     (bool)          [create,query,edit]
            Visibility of the shot imageplane, this value is assigned to the currentCamera's
            imagePlane.
        
        - linkAudio : la                 (unicode)       [create,query,edit]
            Specify an audio clip to link to this shot. Any currently linked audio will be
            unlinked.
        
        - lock : lck                     (bool)          [create,query,edit]
            Lock a specific shot. This is different than locking an entire track, which is
            done via the shotTrack command
        
        - mute : m                       (bool)          [create,query,edit]
            Mute a specific shot. This is different than muting an entire track, which is
            done via the shotTrack command. Querying this attribute will return true if the
            shot is muted due to its own mute, its shot being muted, or its shot being
            unsoloed. See flag selfmuteto query only the shot's own state.
        
        - paste : p                      (bool)          [create,query,edit]
            This flag is used to paste a shot or shots from the clipboard to the sequence
            timeline. Shots are added to the clipboard using the c/copy flag.
        
        - pasteInstance : pi             (bool)          [create,query,edit]
            This flag is used to paste an instance of a shot or shots from the clipboard to
            the sequence timeline. Unlike the p/paste flag, which duplicates the camera and
            image plane from the original source shot, the pi/pasteInstance flag shares the
            camera and image plane from the source shot. The audio node is duplicated.
        
        - postHoldTime : pst             (time)          [create,query,edit]
            Specify the time length to append to the shot in the sequence timeline. This
            repeats the last frame of the shot, in sequence time, over the specified
            duration.
        
        - preHoldTime : prt              (time)          [create,query,edit]
            Specify the time length to prepend to the shot in the sequence timeline. This
            repeats the first frame of the shot, in sequence time, over the specified
            duration.
        
        - scale : s                      (float)         [create,query,edit]
            Specify an amount to scale the Maya frame range of the shot. This will affect
            the sequenceEndFrame, leaving the sequenceStartFrame unchanged.
        
        - selfmute : sm                  (bool)          [create,query,edit]
            Query if this individual shot's own mute state is set. This is different from
            the flag mute, which will return true if this shot is muted due to the track
            being muted or another track being soloed. Editing this flag will set this
            shot's own mute status (identical behavior as the flag mute).
        
        - sequenceDuration : sqd         (time)          [query,edit]
            Return the sequence duration of the shot, which will include the holds and
            scale. This flag can only be queried.
        
        - sequenceEndTime : set          (time)          [create,query,edit]
            The shot end in the sequence timeline. Changing the endTime of a shot will scale
            it in sequence time.
        
        - sequenceStartTime : sst        (time)          [create,query,edit]
            The shot start in the sequence timeline. Changing the startTime of a shot will
            shift it in sequence time.
        
        - shotName : sn                  (unicode)       [create,query,edit]
            Specify a user-defined name for this shot. This allows the assignment of names
            that are not valid as node names within Maya. Whenever the shotName attribute is
            defined its value is used in the UI.
        
        - sourceDuration : sd            (time)          [query,edit]
            Return the number of source frames in the shot. This flag can only be queried.
        
        - startTime : st                 (time)          [create,query,edit]
            The shot start time in the Maya timeline. Changing the startTime will extend the
            duration of a shot.
        
        - track : trk                    (int)           [query,edit]
            Specify the track in which this shot resides.
        
        - transitionInLength : til       (time)          [create,query,edit]
            Length of the transtion into the shot.
        
        - transitionInType : tit         (int)           [query,edit]
            Specify the the type of transition for the transition into the shot. 0 = Fade 1
            = Dissolve
        
        - transitionOutLength : tol      (time)          [create,query,edit]
            Length of the transtion out of the shot.
        
        - transitionOutType : tot        (int)           [query,edit]
            Specify the the type of transition for the transition out of the shot. 0 = Fade
            1 = Dissolve
        
        - unlinkAudio : ula              (bool)          [query,edit]
            COMMENT Unlinks any currently linked audio.                                Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.shot`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PairBlend(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getInput1(self, **kwargs):
        """
        Returns a string array of the node(s) connected to input 1.                                
        
        
        Derived from mel command `maya.cmds.pairBlend`
        """
        pass
    def getInput2(self, **kwargs):
        """
        Returns a string array of the node(s) connected to input 2.                                
        
        
        Derived from mel command `maya.cmds.pairBlend`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The pairBlend node allows a weighted combinations of 2 inputs to be blended
        together. It is created automatically when keying or constraining an attribute
        which is already connected.Alternatively, the pairBlend command can be used to
        connect a pairBlend node to connected attributes of a node. The previously
        existing connections are rewired to input1 of the pairBlend node. Additional
        connections can then be made manually to input2 of the pairBlend node. The
        pairBlend command can also be used to query the inputs to an existing pairBlend
        node.
        
        Flags:
        - attribute : at                 (unicode)       [create]
            The name of the attribute(s) which the blend will drive. This flag is required
            when creating the blend.
        
        - input1 : i1                    (bool)          [query]
            Returns a string array of the node(s) connected to input 1.
        
        - input2 : i2                    (bool)          [query]
            Returns a string array of the node(s) connected to input 2.
        
        - node : nd                      (unicode)       [create]
            The name of the node which the blend will drive. This flag is required when
            creating the blend.                                    Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.pairBlend`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GeomBind(DependNode):
    def getFalloff(self, **kwargs):
        """
        Falloff controlling the bind stiffness. Valid values range from [0..1].                                    
        
        
        Derived from mel command `maya.cmds.geomBind`
        """
        pass
    def getGeodesicVoxelParams(self, **kwargs):
        """
        Specifies the geodesic voxel binding parameters. This flag is composed of three parameters: 0 - Maximum voxel grid resolution which must be a power of two. (ie. 64, 128, 256, etc. ) 1 - Performs a post voxel state validation when enabled. Default values are 256 true.                                
        
        
        Derived from mel command `maya.cmds.geomBind`
        """
        pass
    def getMaxInfluences(self, **kwargs):
        """
        Specifies the maximum influences a vertex can have. By default, all influences are used (-1).                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.geomBind`
        """
        pass
    def setFalloff(self, val='True', **kwargs):
        """
        Falloff controlling the bind stiffness. Valid values range from [0..1].                                    
        
        
        Derived from mel command `maya.cmds.geomBind`
        """
        pass
    def setGeodesicVoxelParams(self, val='True', **kwargs):
        """
        Specifies the geodesic voxel binding parameters. This flag is composed of three parameters: 0 - Maximum voxel grid resolution which must be a power of two. (ie. 64, 128, 256, etc. ) 1 - Performs a post voxel state validation when enabled. Default values are 256 true.                                
        
        
        Derived from mel command `maya.cmds.geomBind`
        """
        pass
    def setMaxInfluences(self, val='True', **kwargs):
        """
        Specifies the maximum influences a vertex can have. By default, all influences are used (-1).                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.geomBind`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to compute weights using geodesic voxel binding algorithm.
        It works by setting the right weights values on an already-existing skinCluster
        node.            In query mode, return type is based on queried flag.
        
        Flags:
        - bindMethod : bm                (int)           [create]
            Specifies which bind algorithm to use. By default, Geodesic Voxel will be used.
            Available algorithms are: 3 - Geodesic Voxel
        
        - falloff : fo                   (float)         [create,query,edit]
            Falloff controlling the bind stiffness. Valid values range from [0..1].
        
        - geodesicVoxelParams : gvp      (int, bool)     [create,query,edit]
            Specifies the geodesic voxel binding parameters. This flag is composed of three
            parameters: 0 - Maximum voxel grid resolution which must be a power of two. (ie.
            64, 128, 256, etc. ) 1 - Performs a post voxel state validation when enabled.
            Default values are 256 true.
        
        - maxInfluences : mi             (int)           [create,query,edit]
            Specifies the maximum influences a vertex can have. By default, all influences
            are used (-1).                              Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.geomBind`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GlobalCacheControl(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Blend(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - autoDirection : ad             (bool)          []
        
        - caching : cch                  (bool)          []
        
        - constructionHistory : ch       (bool)          []
        
        - crvsInFirstRail : cfr          (int)           []
        
        - flipLeft : fl                  (bool)          []
        
        - flipRight : fr                 (bool)          []
        
        - frozen : fzn                   (bool)          []
        
        - leftParameter : lp             (float)         []
        
        - multipleKnots : mk             (bool)          []
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           []
        
        - object : o                     (bool)          []
        
        - polygon : po                   (int)           []
        
        - positionTolerance : pt         (float)         []
        
        - rightParameter : rp            (float)         []
        
        - tangentTolerance : tt          (float)         []
        
        
        Derived from mel command `maya.cmds.blend`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class JointFfd(DependNode):
    """
    # TODO: if jointFfd bug ever fixed:
    #   - remove entry in apiCache.ApiCache.API_TO_MFN_OVERRIDES
    #   - remove hard-code setting of JointFfd's parent to DependNode
    """
    
    
    
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Script(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Unknown(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class MotionPath(DependNode):
    def addAnimatedObject(self, objectToAnimate, modifier='None'):
        """
        Add an object to be animated along this motion path.
        
        Parameters:
        objectToAnimate : 'PyNode'
            A DAG path to the animated object
        modifier : 'MDGModifier'
            The object that will hold the undo information
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.addAnimatedObject`
        """
        pass
    def getAnimatedObjects(self):
        """
        Returns an array of dag paths to the animated objects for this motion path.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.getAnimatedObjects`
        """
        pass
    def getBank(self):
        """
        Determines whether bank has been enabled for this motion path.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.bank`
        """
        pass
    def getBankScale(self):
        """
        Return the bank scale for this motion path.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.bankScale`
        """
        pass
    def getBankThreshold(self):
        """
        Return the bank threshold for this motion path. The bank threshold is used to specify the maximum bank angle. The default value is 90 degrees.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.bankThreshold`
        """
        pass
    def getFollow(self):
        """
        Determines whether follow is set for this motion path node.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.follow`
        """
        pass
    def getFollowAxis(self):
        """
        Return the follow axis for this motion path.
        
        Returns:
        'MotionPath.Axis'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.followAxis`
        """
        pass
    def getInverseNormal(self):
        """
        Determines whether the up-axis of the animated object for this motion path is aligned to the opposite direction of the normal vector of the path geometry.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.inverseNormal`
        """
        pass
    def getOrientationMarker(self, markerNum):
        """
        Gets the orientation marker where markerNum is the order in which the marker was created.
        
        Parameters:
        markerNum : 'int'
            The number of the marker
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.getOrientationMarker`
        """
        pass
    def getPathObject(self):
        """
        Return a dag path to the motion path object. The motion path object is the curve/surface that animated objects of this node will move along.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.pathObject`
        """
        pass
    def getPositionMarker(self, markerNum):
        """
        Gets the position marker where markerNum is the order in which the marker was created.
        
        Parameters:
        markerNum : 'int'
            The number of the marker
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.getPositionMarker`
        """
        pass
    def getUEnd(self):
        """
        Returns the end value of the u parameterization for the animation.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.uEnd`
        """
        pass
    def getUStart(self):
        """
        Returns the starting value of the u parameterization for the animation.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.uStart`
        """
        pass
    def getUTimeEnd(self):
        """
        Returns the end time of the animation for the u parameter.
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.uTimeEnd`
        """
        pass
    def getUTimeStart(self):
        """
        Returns the start time of the animation for the u parameter.
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.uTimeStart`
        """
        pass
    def getUpAxis(self):
        """
        Return the up-axis for this motion path.
        
        Returns:
        'MotionPath.Axis'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.upAxis`
        """
        pass
    def getUseNormal(self):
        """
        Determines whether the up-axis of the animated object for this motion path is aligned with the normal vector of the path geometry.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.useNormal`
        """
        pass
    def numOrientationMarkers(self):
        """
        Returns the number of orientation markers on this motion path.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.numOrientationMarkers`
        """
        pass
    def numPositionMarkers(self):
        """
        Returns the number of position markers on this motion path.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.numPositionMarkers`
        """
        pass
    def setBank(self, bank):
        """
        bank
        
        Parameters:
        bank : 'bool'
            Specifies whether bank is turned on
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setBank`
        """
        pass
    def setBankScale(self, bankScale):
        """
        Set the bank scale for this motion path. If the computed bank angles are not large enough, the user can specify the bankScale to amplify them. The default value is 1.
        
        Parameters:
        bankScale : 'float'
            The new bank scale value
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setBankScale`
        """
        pass
    def setBankThreshold(self, bankThreshold):
        """
        Set the bank threshold for this motion path. The bank threshold is used to specify the maximum bank angle. The default value is 90 degrees.
        
        Parameters:
        bankThreshold : 'float'
            The new bank threshold value
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setBankThreshold`
        """
        pass
    def setFollow(self, on, modifier='None'):
        """
        Setting follow on will cause the animated object(s) local axis to be aligned with the tangent of the motion path. The default alignment axis is Y.
        
        Parameters:
        on : 'bool'
            Specifies whether follow is activated for this motion path
        modifier : 'MDGModifier'
            The object that will hold the undo information
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setFollow`
        """
        pass
    def setFollowAxis(self, axis):
        """
        Sets the axis of the animated object that will follow the motion path. Possible alignment parameters are kXaxis, kYaxiz, or kZaxis.
        
        Parameters:
        axis : 'MotionPath.Axis'
            Object axis to align with motion path tangent
        
            values: 'xaxis', 'yaxis', 'zaxis'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setFollowAxis`
        """
        pass
    def setInverseNormal(self, invert):
        """
        If true, enable alignment of the up axis of the moving object(s) to the opposite direction of the normal vector of the path geometry.
        
        Parameters:
        invert : 'bool'
            Specifies if inverse normal is used
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setInverseNormal`
        """
        pass
    def setPathObject(self, pathObject, modifier='None'):
        """
        Set the curve or surface for this motion path. All animated objects for this motion path will follow the new path that is specified.
        
        Parameters:
        pathObject : 'PyNode'
            The curve (or surface) that will be the motion path
        modifier : 'MDGModifier'
            The object that will hold the undo information
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setPathObject`
        """
        pass
    def setUEnd(self, end):
        """
        Sets the end value of the u parameterization for the animation.
        
        Parameters:
        end : 'float'
            the new end value
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setUEnd`
        """
        pass
    def setUStart(self, start):
        """
        Sets the starting value of the u parameterization for the animation.
        
        Parameters:
        start : 'float'
            the new start value
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setUStart`
        """
        pass
    def setUTimeEnd(self, end):
        """
        Sets the end time of the animation for the u parameter.
        
        Parameters:
        end : 'Time'
            the new end time
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setUTimeEnd`
        """
        pass
    def setUTimeStart(self, start):
        """
        Sets the starting time of the animation for the u parameter.
        
        Parameters:
        start : 'Time'
            the new start time
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setUTimeStart`
        """
        pass
    def setUpAxis(self, axis):
        """
        Set the up-axis for this motion path.
        
        Parameters:
        axis : 'MotionPath.Axis'
            Axis to be set
        
            values: 'xaxis', 'yaxis', 'zaxis'
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setUpAxis`
        """
        pass
    def setUseNormal(self, use):
        """
        If true, enables alignment of the up axis of the animated object to the normal vector of the path geometry.
        
        Parameters:
        use : 'bool'
            Specifies if normal is used
        
        Derived from api method `maya.OpenMayaAnim.MFnMotionPath.setUseNormal`
        """
        pass
    Axis = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class EditsManager(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class RigidSolver(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getAutoTolerances(self, **kwargs):
        """
        Turns the auto tolerance calculation on and off.  The auto tolerances calculation will override the default or user defined values of the step size and collision tolerance value that is calculated based on the objects in the scene. Default: 0 (off)                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getBounciness(self, **kwargs):
        """
        Turns bounciness on and off for the an the objects in the simulation. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getCacheData(self, **kwargs):
        """
        Turns the cache on fall all rigid bodies in the system. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getCollide(self, **kwargs):
        """
        Disallows the interpenetration of the two rigid bodies listed. Default: Collide is on for all bodies.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getCollisionTolerance(self, **kwargs):
        """
        Sets the collision tolerance.  This is the error at which two objects are considered to have collided. Range:   0.0005 - 1.000 Default: 0.02                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getContactData(self, **kwargs):
        """
        Turns the contact data information on/off for all rigid bodies. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getDeleteCache(self, **kwargs):
        """
        Deletes the cache for all rigid bodies in the system.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getDisplayCenterOfMass(self, **kwargs):
        """
        Displays the center of mass icon. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getDisplayConstraint(self, **kwargs):
        """
        Displays the constraint vectors. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getDisplayVelocity(self, **kwargs):
        """
        Displays the velocity vectors. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getDynamics(self, **kwargs):
        """
        Turns dynamics on and off for the an the objects in the simulation. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getFriction(self, **kwargs):
        """
        Turns friction on and off for the an the objects in the simulation. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getInterpenetrate(self, **kwargs):
        """
        Allows the two rigid bodies listed to interpenetrate. Default: interpenetration is off for all bodies.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getRigidBodies(self, **kwargs):
        """
        Returns a list of rigid bodies in the solver.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getRigidBodyCount(self, **kwargs):
        """
        Returns the number of rigid bodies in the solver.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getShowCollision(self, **kwargs):
        """
        Displays the colliding objects in a different color.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getShowInterpenetration(self, **kwargs):
        """
        Displays the interpenetrating objects in a different color.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getSolverMethod(self, **kwargs):
        """
        Sets the solver method.  The choices are 0 | 1 | 2. 0 = Euler (fastest/least acurate), 1 = Runge-Kutta ( slower/more acurate), 2 = adaptive Runge-Kutta (slowest/most acurate). The default is 2 (adaptive Runge-Kutta)                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getStartTime(self, **kwargs):
        """
        Sets the start time for the solver.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getState(self, **kwargs):
        """
        Turns the rigid solver on or off.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getStatistics(self, **kwargs):
        """
        Turns the statistic information on/off for all rigid bodies. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getStepSize(self, **kwargs):
        """
        Sets the solvers step size.  This is the maximum size of a single step the solver will take at one time. Range:   0.0004 - 0.100 Default: 0.0333                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def getVelocityVectorScale(self, **kwargs):
        """
        scales the velocity vector display. Default value: 1.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def interpenetrationCheck(self, val='True', **kwargs):
        """
        Checks for interpenetrating rigid bodies in the scene.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setAutoTolerances(self, val='True', **kwargs):
        """
        Turns the auto tolerance calculation on and off.  The auto tolerances calculation will override the default or user defined values of the step size and collision tolerance value that is calculated based on the objects in the scene. Default: 0 (off)                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setBounciness(self, val='True', **kwargs):
        """
        Turns bounciness on and off for the an the objects in the simulation. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setCacheData(self, val='True', **kwargs):
        """
        Turns the cache on fall all rigid bodies in the system. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setCollide(self, val='True', **kwargs):
        """
        Disallows the interpenetration of the two rigid bodies listed. Default: Collide is on for all bodies.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setCollisionTolerance(self, val='True', **kwargs):
        """
        Sets the collision tolerance.  This is the error at which two objects are considered to have collided. Range:   0.0005 - 1.000 Default: 0.02                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setContactData(self, val='True', **kwargs):
        """
        Turns the contact data information on/off for all rigid bodies. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setDeleteCache(self, val='True', **kwargs):
        """
        Deletes the cache for all rigid bodies in the system.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setDisplayCenterOfMass(self, val='True', **kwargs):
        """
        Displays the center of mass icon. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setDisplayConstraint(self, val='True', **kwargs):
        """
        Displays the constraint vectors. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setDisplayVelocity(self, val='True', **kwargs):
        """
        Displays the velocity vectors. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setDynamics(self, val='True', **kwargs):
        """
        Turns dynamics on and off for the an the objects in the simulation. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setFriction(self, val='True', **kwargs):
        """
        Turns friction on and off for the an the objects in the simulation. Default value: on                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setInterpenetrate(self, val='True', **kwargs):
        """
        Allows the two rigid bodies listed to interpenetrate. Default: interpenetration is off for all bodies.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setShowCollision(self, val='True', **kwargs):
        """
        Displays the colliding objects in a different color.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setShowInterpenetration(self, val='True', **kwargs):
        """
        Displays the interpenetrating objects in a different color.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setSolverMethod(self, val='True', **kwargs):
        """
        Sets the solver method.  The choices are 0 | 1 | 2. 0 = Euler (fastest/least acurate), 1 = Runge-Kutta ( slower/more acurate), 2 = adaptive Runge-Kutta (slowest/most acurate). The default is 2 (adaptive Runge-Kutta)                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setStartTime(self, val='True', **kwargs):
        """
        Sets the start time for the solver.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setState(self, val='True', **kwargs):
        """
        Turns the rigid solver on or off.                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setStatistics(self, val='True', **kwargs):
        """
        Turns the statistic information on/off for all rigid bodies. Default value: off                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setStepSize(self, val='True', **kwargs):
        """
        Sets the solvers step size.  This is the maximum size of a single step the solver will take at one time. Range:   0.0004 - 0.100 Default: 0.0333                  
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    def setVelocityVectorScale(self, val='True', **kwargs):
        """
        scales the velocity vector display. Default value: 1.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command sets the attributes for the rigid solver            In query mode,
        return type is based on queried flag.
        
        Flags:
        - autoTolerances : at            (bool)          [query,edit]
            Turns the auto tolerance calculation on and off.  The auto tolerances
            calculation will override the default or user defined values of the step size
            and collision tolerance value that is calculated based on the objects in the
            scene. Default: 0 (off)
        
        - bounciness : b                 (bool)          [query,edit]
            Turns bounciness on and off for the an the objects in the simulation. Default
            value: on
        
        - cacheData : cd                 (bool)          [query,edit]
            Turns the cache on fall all rigid bodies in the system. Default value: off
        
        - collide : c                    (bool)          [query,edit]
            Disallows the interpenetration of the two rigid bodies listed. Default: Collide
            is on for all bodies.
        
        - collisionTolerance : ct        (float)         [query,edit]
            Sets the collision tolerance.  This is the error at which two objects are
            considered to have collided. Range:   0.0005 - 1.000 Default: 0.02
        
        - contactData : ctd              (bool)          [query,edit]
            Turns the contact data information on/off for all rigid bodies. Default value:
            off
        
        - create : cr                    (bool)          [create]
            Creates a new rigid solver.
        
        - current : cu                   (bool)          [create]
            Sets rigid solver as the current solver.
        
        - deleteCache : deleteCache      (bool)          [query,edit]
            Deletes the cache for all rigid bodies in the system.
        
        - displayCenterOfMass : dcm      (bool)          [query,edit]
            Displays the center of mass icon. Default value: on
        
        - displayConstraint : dc         (bool)          [query,edit]
            Displays the constraint vectors. Default value: on
        
        - displayVelocity : dv           (bool)          [query,edit]
            Displays the velocity vectors. Default value: off
        
        - dynamics : d                   (bool)          [query,edit]
            Turns dynamics on and off for the an the objects in the simulation. Default
            value: on
        
        - friction : f                   (bool)          [query,edit]
            Turns friction on and off for the an the objects in the simulation. Default
            value: on
        
        - interpenetrate : i             (bool)          [query,edit]
            Allows the two rigid bodies listed to interpenetrate. Default: interpenetration
            is off for all bodies.
        
        - interpenetrationCheck : ic     (bool)          [edit]
            Checks for interpenetrating rigid bodies in the scene.
        
        - name : n                       (unicode)       [create,query,edit]
            Name of the new object
        
        - rigidBodies : rb               (bool)          [query]
            Returns a list of rigid bodies in the solver.
        
        - rigidBodyCount : rbc           (bool)          [query]
            Returns the number of rigid bodies in the solver.
        
        - showCollision : sc             (bool)          [query,edit]
            Displays the colliding objects in a different color.
        
        - showInterpenetration : si      (bool)          [query,edit]
            Displays the interpenetrating objects in a different color.
        
        - solverMethod : sm              (int)           [query,edit]
            Sets the solver method.  The choices are 0 | 1 | 2. 0 = Euler (fastest/least
            acurate), 1 = Runge-Kutta ( slower/more acurate), 2 = adaptive Runge-Kutta
            (slowest/most acurate). The default is 2 (adaptive Runge-Kutta)
        
        - startTime : stt                (float)         [create,query,edit]
            Sets the start time for the solver.
        
        - state : st                     (bool)          [query,edit]
            Turns the rigid solver on or off.
        
        - statistics : sta               (bool)          [query,edit]
            Turns the statistic information on/off for all rigid bodies. Default value: off
        
        - stepSize : s                   (float)         [query,edit]
            Sets the solvers step size.  This is the maximum size of a single step the
            solver will take at one time. Range:   0.0004 - 0.100 Default: 0.0333
        
        - velocityVectorScale : vs       (float)         [query,edit]
            scales the velocity vector display. Default value: 1.0                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.rigidSolver`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SkinBinding(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class HyperView(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TadskAssetInstanceNode_TdependNode(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class DistanceBetween(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdivComponentId(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Reverse(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PoseInterpolatorManager(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderGlobalsList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class LightInfo(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class BlindDataTemplate(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PassMatrix(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Record(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Expression(DependNode):
    def evaluate(self):
        """
        Evaluate this expression and return the result.
        
        Returns:
        List['float']
        
        Derived from api method `maya.OpenMaya.MFnExpression.evaluate`
        """
        pass
    def getAlwaysEvaluate(self, **kwargs):
        """
        If this is TRUE (the default), then the expression will be evaluated whenever time changes regardless of whether the other inputs have changed, and an output is requested.  If it is FALSE, then the expression will only be evaluated if one or more of the inputs changes and an output is requested.  Note, if 'time' or 'frame' are inputs, then the expression will act as if this was set to TRUE.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getAnimated(self, **kwargs):
        """
        Sets the animation mode on the expression node: 0 = Not Animated, 1 = Animated, 2 = Animated with No Callback.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        Sets the name of the attribute to use for the expression                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getDefaultObject(self):
        """
        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.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnExpression.getDefaultObject`
        """
        pass
    def getExpression(self):
        """
        Gets the expression string for this expression node.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnExpression.expression`
        """
        pass
    def getObject(self, **kwargs):
        """
        Sets the defaultobject for the expression.  This allows the expression writer to not type the object name for frequently-used objects.  See the examples below.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getSafe(self, **kwargs):
        """
        Returns true if no potential side effect can occurs running that expression. Safe expression will be optimized to evaluate only when needed even if flagged alwaysEvaluate.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getShortNames(self, **kwargs):
        """
        When used with the -q/query flag, tells the command to return the expression with attribute names as short as possible. The default is to return the FULL attribute name, regardless of how the user entered it into the expression, including the object names.  With this flag set, attribute names are returned as their short versions, and any attribute that belongs to the default object, if there is one specified, will not display the object's name.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getString(self, **kwargs):
        """
        Set the expression string                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getTimeDependent(self, **kwargs):
        """
        Returns true if expression refer to 'time' or 'frame' keywords. Those reference force the connection to time. If the expression is flagged as safe and not time dependend, then they will always evaluate on depend, even if alwaysEvaluate is on. Otherwise time change will dirty the expression.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def getUnitConversion(self):
        """
        Get the unit conversion status for the expression node.
        
        Returns:
        'Expression.UnitConversion'
        
        Derived from api method `maya.OpenMaya.MFnExpression.unitConversion`
        """
        pass
    def isAnimated(self):
        """
        If this is true, then the expression will be evaluated whenever time changes, regardless of whether the other inputs have changed.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnExpression.isAnimated`
        """
        pass
    def setAlwaysEvaluate(self, val='True', **kwargs):
        """
        If this is TRUE (the default), then the expression will be evaluated whenever time changes regardless of whether the other inputs have changed, and an output is requested.  If it is FALSE, then the expression will only be evaluated if one or more of the inputs changes and an output is requested.  Note, if 'time' or 'frame' are inputs, then the expression will act as if this was set to TRUE.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def setAnimated(self, value='False'):
        """
        Sets the way in which the expression is evaluated.
        
        Parameters:
        value : 'bool'
            sets the objects evaluation type
        
        Derived from api method `maya.OpenMaya.MFnExpression.setAnimated`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        Sets the name of the attribute to use for the expression                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def setDefaultObject(self, object):
        """
        Sets the "default" object for the expression. This allows the expression writer to not type the object name for frequently-used objects.
        
        Parameters:
        object : 'PyNode'
            the object to be set
        
        Derived from api method `maya.OpenMaya.MFnExpression.setDefaultObject`
        """
        pass
    def setExpression(self, expression):
        """
        Sets the expression string for this expression node.
        
        Parameters:
        expression : 'unicode'
            The expression string
        
        Derived from api method `maya.OpenMaya.MFnExpression.setExpression`
        """
        pass
    def setObject(self, val='True', **kwargs):
        """
        Sets the defaultobject for the expression.  This allows the expression writer to not type the object name for frequently-used objects.  See the examples below.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def setShortNames(self, val='True', **kwargs):
        """
        When used with the -q/query flag, tells the command to return the expression with attribute names as short as possible. The default is to return the FULL attribute name, regardless of how the user entered it into the expression, including the object names.  With this flag set, attribute names are returned as their short versions, and any attribute that belongs to the default object, if there is one specified, will not display the object's name.                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def setString(self, val='True', **kwargs):
        """
        Set the expression string                  
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    def setUnitConversion(self, conversion):
        """
        Set the unit conversion options for the expression node.
        
        Parameters:
        conversion : 'Expression.UnitConversion'
            unit conversion state for this node
        
            values: 'all', 'none', 'angularOnly'
        
        Derived from api method `maya.OpenMaya.MFnExpression.setUnitConversion`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command describes an expression that belongs to the current scene. The
        expression is a block of code of unlimited length with a C-like syntax that can
        perform conversions, mathematical operations, and logical decision making on any
        numeric attribute(s) in the scene.  One expression can read and alter any number
        of numeric attributes.  Theoretically, every expression in a scene can be
        combined into one long expression, but it is recommended that they are separated
        for ease of use and editing, as well as efficiency.If this command is being sent
        by the command line or in a script, then the user should be sure to embed
        escaped newlines (\n), tabs (\t) for clarity when reading them in the expression
        editor.  Also, quotes in an expression must be escaped (\) so that they are not
        confused by the system as the end of your string.  When using the expression
        editor, these characters are escaped for you unless they are already within
        quotes.Note, expressions that alter or use per-particle attributes of a particle
        shape should use the 'dynExpression' command.
        
        Flags:
        - alwaysEvaluate : ae            (int)           [create,query,edit]
            If this is TRUE (the default), then the expression will be evaluated whenever
            time changes regardless of whether the other inputs have changed, and an output
            is requested.  If it is FALSE, then the expression will only be evaluated if one
            or more of the inputs changes and an output is requested.  Note, if 'time' or
            'frame' are inputs, then the expression will act as if this was set to TRUE.
        
        - animated : an                  (int)           [create,query,edit]
            Sets the animation mode on the expression node: 0 = Not Animated, 1 = Animated,
            2 = Animated with No Callback.
        
        - attribute : a                  (unicode)       [create,query,edit]
            Sets the name of the attribute to use for the expression
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the dependency graph node to use for the expression
        
        - object : o                     (unicode)       [create,query,edit]
            Sets the defaultobject for the expression.  This allows the expression writer to
            not type the object name for frequently-used objects.  See the examples below.
        
        - safe : sf                      (bool)          [query]
            Returns true if no potential side effect can occurs running that expression.
            Safe expression will be optimized to evaluate only when needed even if flagged
            alwaysEvaluate.
        
        - shortNames : sn                (bool)          [create,query,edit]
            When used with the -q/query flag, tells the command to return the expression
            with attribute names as short as possible. The default is to return the FULL
            attribute name, regardless of how the user entered it into the expression,
            including the object names.  With this flag set, attribute names are returned as
            their short versions, and any attribute that belongs to the default object, if
            there is one specified, will not display the object's name.
        
        - string : s                     (unicode)       [create,query,edit]
            Set the expression string
        
        - timeDependent : td             (bool)          [query]
            Returns true if expression refer to 'time' or 'frame' keywords. Those reference
            force the connection to time. If the expression is flagged as safe and not time
            dependend, then they will always evaluate on depend, even if alwaysEvaluate is
            on. Otherwise time change will dirty the expression.
        
        - unitConversion : uc            (unicode)       [query,edit]
            Insert specified unit conversion nodes at creation: all, none,or
            angularOnly.Default is all.For angularOnly, will insert unit conversion nodes
            only for angular attributes (allowing degrees-to-radians conversion).  This is
            for performance tuning. If queried, returns the option used when the expression
            was created or last edited.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.expression`
        """
        pass
    UnitConversion = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OpticalFX(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PointMatrixMult(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class GeoConnector(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SelectionListOperator(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AddMatrix(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdivCollapse(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeEditorInterpolator(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class LightList(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Add/Remove a relationship between an object and the current light. Soon to be
        replaced by the connect-attribute command. In query mode, return type is based
        on queried flag.
        
        Flags:
        - add : add                      (PyNode)        [create]
            add object(s) to light list.
        
        - remove : rm                    (PyNode)        [create]
            remove object(s) to light list.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.lightList`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SetRange(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class GreasePencilSequence(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class Snapshot(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        update with changes to original geometry                  
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def getEndTime(self, **kwargs):
        """
        time to stop copying target geometry Default: 10.0                  
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def getIncrement(self, **kwargs):
        """
        time increment between copies Default: 1.0                  
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def getStartTime(self, **kwargs):
        """
        time to begin copying target geometry Default: 1.0                  
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def getUpdate(self, **kwargs):
        """
        This flag can only be used if the snapshot has constructionHistory. It sets the snapshot node's update value. The update value controls whether the snapshot updates on demand (most efficient), when keyframes change (efficient), or whenever any history changes (least efficient). Valid values are demand, animCurve, always. Default: alwaysFlag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setEndTime(self, val='True', **kwargs):
        """
        time to stop copying target geometry Default: 10.0                  
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def setIncrement(self, val='True', **kwargs):
        """
        time increment between copies Default: 1.0                  
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def setStartTime(self, val='True', **kwargs):
        """
        time to begin copying target geometry Default: 1.0                  
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    def setUpdate(self, val='True', **kwargs):
        """
        This flag can only be used if the snapshot has constructionHistory. It sets the snapshot node's update value. The update value controls whether the snapshot updates on demand (most efficient), when keyframes change (efficient), or whenever any history changes (least efficient). Valid values are demand, animCurve, always. Default: alwaysFlag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command can be used to create either a series of surfaces evaluated at the
        times specified by the command flags, or a motion trail displaying the
        trajectory of the object's pivot point at the times specified.If the
        constructionHistory flag is true, the output shapes or motion trail will re-
        update when modifications are made to the animation or construction history of
        the original shape. When construction history is used, the forceUpdate flag can
        be set to false to control when the snapshot recomputes, which will typically
        improve performance.
        
        Flags:
        - anchorTransform : at           (unicode)       []
        
        - constructionHistory : ch       (bool)          [create,query]
            update with changes to original geometry
        
        - endTime : et                   (time)          [create,query,edit]
            time to stop copying target geometry Default: 10.0
        
        - increment : i                  (time)          [create,query,edit]
            time increment between copies Default: 1.0
        
        - motionTrail : mt               (bool)          [create]
            Rather than create a series of surfaces, create a motion trail displaying the
            location of the object's pivot point at the specified time steps. Default is
            false.
        
        - motionTrailName : mtn          (unicode)       []
        
        - name : n                       (unicode)       [create,query,edit]
            the name of the snapshot node. Query returns string.
        
        - removeAnchorTransform : rat    (unicode)       []
        
        - startTime : st                 (time)          [create,query,edit]
            time to begin copying target geometry Default: 1.0
        
        - update : u                     (unicode)       [create,query,edit]
            This flag can only be used if the snapshot has constructionHistory. It sets the
            snapshot node's update value. The update value controls whether the snapshot
            updates on demand (most efficient), when keyframes change (efficient), or
            whenever any history changes (least efficient). Valid values are demand,
            animCurve, always. Default: alwaysFlag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.snapshot`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Membrane(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RemapHsv(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SurfaceShader(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Facade(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ThreadedDevice(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AbstractBaseCreate(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SequenceManager(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getCurrentShot(self, **kwargs):
        """
        Returns the shot that is being used at the current sequence time.                                  
        
        
        Derived from mel command `maya.cmds.sequenceManager`
        """
        pass
    def getCurrentTime(self, **kwargs):
        """
        Set the current sequence time                              
        
        
        Derived from mel command `maya.cmds.sequenceManager`
        """
        pass
    def getModelPanel(self, **kwargs):
        """
        Sets a dedicated modelPanel to be used as the panel that the sequencer will control.                               
        
        
        Derived from mel command `maya.cmds.sequenceManager`
        """
        pass
    def getNode(self, **kwargs):
        """
        Returns the SequenceManager node, of which there is only ever one.                                 
        
        
        Derived from mel command `maya.cmds.sequenceManager`
        """
        pass
    def getWritableSequencer(self, **kwargs):
        """
        Get the writable sequencer node.  Create it if it doesn't exist.                                   Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.sequenceManager`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The sequenceManager command manages sequences, shots, and their related scenes.
        In query mode, return type is based on queried flag.
        
        Flags:
        - addSequencerAudio : asa        (unicode)       [create]
            Add an audio clip to the sequencer by specifying a filename
        
        - attachSequencerAudio : ata     (unicode)       [create]
            Add an audio clip to the sequencer by specifying an audio node
        
        - currentShot : cs               (unicode)       [query]
            Returns the shot that is being used at the current sequence time.
        
        - currentTime : ct               (time)          [create,query]
            Set the current sequence time
        
        - listSequencerAudio : lsa       (unicode)       [create]
            List the audio clips added to the sequencer
        
        - listShots : lsh                (bool)          [create]
            List all the currently defined shots across all scene segments
        
        - modelPanel : mp                (unicode)       [create,query]
            Sets a dedicated modelPanel to be used as the panel that the sequencer will
            control.
        
        - node : nd                      (unicode)       [query]
            Returns the SequenceManager node, of which there is only ever one.
        
        - writableSequencer : ws         (unicode)       [query]
            Get the writable sequencer node.  Create it if it doesn't exist.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.sequenceManager`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ClipLibrary(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PassContributionMap(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Reference(DependNode):
    def associatedNamespace(self, baseName):
        """
        Returns the namespace associated with this reference.
        
        Parameters:
        baseName : 'bool'
            If true, return the base name of the reference
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnReference.associatedNamespace`
        """
        pass
    def containsNode(self, node):
        """
        Returns true if the specified node is from this reference or one of its child references. The containsNodeExactly method can be used to test membership without including the child references.
        
        Parameters:
        node : 'PyNode'
            The node to be checked
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnReference.containsNode`
        """
        pass
    def containsNodeExactly(self, node):
        """
        Returns true if the specified node is from this reference. Membership in child references is not checked. The containsNode method may be used to test membership in a reference and its child references.
        
        Parameters:
        node : 'PyNode'
            The node to be checked
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnReference.containsNodeExactly`
        """
        pass
    def fileName(self, resolvedName, includePath, includeCopyNumber):
        """
        Returns the name of file associated with this reference.
        
        Parameters:
        resolvedName : 'bool'
            If true, return the resolved name rather than the original file name. The unresolved name is the string originally specified when the file was loaded into Maya; this may contain environment variables, may be a relative path, and may otherwise not precisely indicate where the file can be located on disk. The resolved name is the actual path name that Maya is using to locate the file after relative paths and environment variables have been expanded, and any other necessary steps have been used to resolve its physical location.
        includePath : 'bool'
            If true, include the file path in the return string.
        includeCopyNumber : 'bool'
            If true, include the copy number (if there is one) in the return string.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnReference.fileName`
        """
        pass
    def isExportEditsFile(self):
        """
        Returns true if the reference is an export edits file. An export edits file is a file of type ".editMA" or ".editMB" which was created using Maya's offline file functionality.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnReference.isExportEditsFile`
        """
        pass
    def isLoaded(self):
        """
        Returns true if the reference is loaded.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnReference.isLoaded`
        """
        pass
    def isReferenceLocked(self):
        """
        Returns true if the reference is locked or if the referenced file was saved as locked.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnReference.isLocked`
        """
        pass
    def nodes(self):
        """
        Returns an array of the nodes associated with this reference.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnReference.nodes`
        """
        pass
    def parentAssembly(self):
        """
        Returns the parent assembly node that contains this reference. See MFnAssembly documentation for more details.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnReference.parentAssembly`
        """
        pass
    def parentFileName(self, resolveName, includePath, includeCopyNumber):
        """
        Returns the name of parent file associated with this reference.
        
        Parameters:
        resolveName : 'bool'
            If true, return the resolved name rather than the original file name. The unresolved name is the string originally specified when the file was loaded into Maya; this may contain environment variables, may be a relative path, and may otherwise not precisely indicate where the file can be located on disk. The resolved name is the actual path name that Maya is using to locate the file after relative paths and environment variables have been expanded, and any other necessary steps have been used to resolve its physical location.
        includePath : 'bool'
            If true, include the file path in the return string.
        includeCopyNumber : 'bool'
            If true, include the copy number (if there is one) in the return string.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnReference.parentFileName`
        """
        pass
    def parentReference(self):
        """
        Returns the reference node associated with the parent reference.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnReference.parentReference`
        """
        pass
    @classmethod
    def getIgnoreReferenceEdits(self):
        """
        Indicates whether reference edits will be tracked and logged or not.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnReference.ignoreReferenceEdits`
        """
        pass
    @classmethod
    def setIgnoreReferenceEdits(self, ignoreEdits):
        """
        Specify whether reference edits should be tracked and logged or not. This should be treated as a temporary state and should be enabled around a batch of operations where reference edits should be ignored. Restore the previous value when the batch of operations is complete.
        
        Parameters:
        ignoreEdits : 'bool'
            If true reference edits will not be logged.
        
        Derived from api method `maya.OpenMaya.MFnReference.setIgnoreReferenceEdits`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - connectionsBroken : cb         (bool)          []
        
        - connectionsMade : cm           (bool)          []
        
        - dagPath : dp                   (bool)          []
        
        - editCommand : ec               (unicode)       []
        
        - filename : f                   (unicode)       []
        
        - isNodeReferenced : inr         (bool)          []
        
        - longName : ln                  (bool)          []
        
        - node : n                       (unicode)       []
        
        - referenceNode : rfn            (unicode)       []
        
        - shortName : sn                 (bool)          []
        
        
        Derived from mel command `maya.cmds.reference`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class EditMetadata(DependNode):
    def getChannelName(self, **kwargs):
        """
        Filter the metadata selection to only recognize metadata belonging to the specified named Channel (e.g. vertex). This flag is ignored if the components on the selection list are being used to specify the metadata of interest. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.editMetadata`
        """
        pass
    def getChannelType(self, **kwargs):
        """
        Obsolete - use the 'channelName' flag instead. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.editMetadata`
        """
        pass
    def getIndex(self, **kwargs):
        """
        In the typical case metadata is indexed using a simple integer value. Certain types of data may use other index types. e.g. a vertexFacecomponent will use a pairindex type, which is two integer values; one for the face ID of the component and the second for the vertex ID.  The indexflag takes a string, formatted in the way the specified indexTyperequires. All uses of the indexflag have the same indexType. If the type was not specified it is assumed to be a simple integer value.  In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.editMetadata`
        """
        pass
    def getIndexType(self, **kwargs):
        """
        Name of the index type the new Channel should be using. If not specified this defaults to a simple integer index. Of the native types only a mesh vertexFacechannel is different, using a pairindex type. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.editMetadata`
        """
        pass
    def getScene(self, **kwargs):
        """
        Use this flag when you want to add metadata to the scene as a whole rather than to any individual nodes. If you use this flag and have nodes selected the nodes will be ignored and a warning will be displayed.                                   
        
        
        Derived from mel command `maya.cmds.editMetadata`
        """
        pass
    def getStreamName(self, **kwargs):
        """
        Name of the metadata Stream. Depending on context it could be the name of a Stream to be created, or the name of the Stream to pass through the filter. In query mode, this flag can accept a value.Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.editMetadata`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to set metadata elements onto or remove metadata elements
        from an object. Before using this command you must first attach a metadata
        stream type to the object using the addMetadatacommand or an API equivalent. The
        command has four basic variations: Set per-component metadata on meshesRemove
        per-component metadata on meshesSet generic metadata on any objectRemove generic
        metadata on any objectThe difference between the setand removevariations (1,3
        vs. 2,4) is that setrequires both a member name to be set and a new value to be
        set. (The reason removal doesn't use a member name is that you can only remove
        an entire metadata structural element, you cannot remove only a single member
        from it.)  When metadata values are set or removed the action is performed on
        every selected component or index. This provides an easy method to set or remove
        a bunch of metadata en masse.  The general usage (variations 3, 4) lets you
        select specific pieces of metadata through the channelNameand indexflags. Note
        that since indexis a multi-use flag you can select many different elements from
        the same Channel and set or remove the metadata on all of them in one command.
        Metadata on meshes is special in that the Channel types vertex, edge, face, and
        vertexFaceare directly connected to the components of the same name. To make
        setting these metadata Channels easier you can simply select or specify on the
        command line the corresponding components rather than using the channelNameand
        indexflags. For example the selection myMesh.vtx[8:10]corresponds to channelName
        = vertexand index = 8, 9, 10(as a multi-use flag).  Note that the metadata is
        assigned to an object and except in the special case of mesh geometry does not
        flow through the dependency graph. In meshes the metadata will move from node to
        node wherever the geometry is connected, although it will not adjust itself
        automatically for changes in topology. Internal data is arranged to minimize the
        amount of copying no matter how many other nodes are connected to it.  Only a
        single node or scene, component type, channel type, and value type are allowed
        in a single command. This keeps the data simple at the possible cost of
        requiring multiple calls to the command to set more than one structure member's
        value.  Certain nodes have metadata supplied by input attributes. If you edit
        one of those with an incoming connection on such an attribute then the metadata
        edit will not be applied directly it will be put into an 'editMetadata' node for
        application during DG evaluation. Since the details of the metadata are not
        known until the evaluation happens less rigorous compatibility checking is
        performed. The editMetadata node has its own facilities for verifying and
        reporting illegal metadata edits. Successive edits to the same metadata in this
        way appends each edit to the same editMetadata node.
        
        Flags:
        - channelName : cn               (unicode)       [create,query]
            Filter the metadata selection to only recognize metadata belonging to the
            specified named Channel (e.g. vertex). This flag is ignored if the components on
            the selection list are being used to specify the metadata of interest. In query
            mode, this flag can accept a value.
        
        - channelType : cht              (unicode)       [create,query]
            Obsolete - use the 'channelName' flag instead. In query mode, this flag can
            accept a value.
        
        - endIndex : eix                 (unicode)       [create]
            The metadata is stored in a Stream, which is an indexed list. If you have mesh
            components selected then the metadata indices are implicit in the list of
            selected components. If you select only the node or scene then this flag may be
            used in conjunction with the startIndexflag to specify a range of indices from
            which to retrieve the metadata. It is an error to have the value of startIndexbe
            greater than that of endIndex.  See also the indexflag for an alternate way to
            specify multiple indices. This flag can only be used on index types that support
            a range (e.g. integer values - it makes no sense to request a range between two
            strings)  In query mode, this flag can accept a value.
        
        - index : idx                    (unicode)       [create,query]
            In the typical case metadata is indexed using a simple integer value. Certain
            types of data may use other index types. e.g. a vertexFacecomponent will use a
            pairindex type, which is two integer values; one for the face ID of the
            component and the second for the vertex ID.  The indexflag takes a string,
            formatted in the way the specified indexTyperequires. All uses of the indexflag
            have the same indexType. If the type was not specified it is assumed to be a
            simple integer value.  In query mode, this flag can accept a value.
        
        - indexType : idt                (unicode)       [create,query]
            Name of the index type the new Channel should be using. If not specified this
            defaults to a simple integer index. Of the native types only a mesh
            vertexFacechannel is different, using a pairindex type. In query mode, this flag
            can accept a value.
        
        - memberName : mn                (unicode)       [create]
            Name of the Structure member being edited. The names of the members are set up
            in the Structure definition, either through the description passed in through
            the dataStructurecommand or via the API used to create that Structure.
        
        - remove : rem                   (bool)          [create]
            If the removeflag is set then the metadata will be removed rather than have
            values set. In this mode the memberName, value, and stringValueflags are
            ignored. memberNameis ignored because when deleting metadata all members of a
            structure must be removed as a group. The others are ignored since when deleting
            you don't need a value to be set.
        
        - scene : scn                    (bool)          [create,query]
            Use this flag when you want to add metadata to the scene as a whole rather than
            to any individual nodes. If you use this flag and have nodes selected the nodes
            will be ignored and a warning will be displayed.
        
        - startIndex : six               (unicode)       [create]
            The metadata is stored in a Stream, which is an indexed list. If you have mesh
            components selected then the metadata indices are implicit in the list of
            selected components. If you select only the node or scene then this flag may be
            used in conjunction with the endIndexflag to specify a range of indices from
            which to retrieve the metadata. It is an error to have the value of startIndexbe
            greater than that of endIndex.  See also the indexflag for an alternate way to
            specify multiple indices. This flag can only be used on index types that support
            a range (e.g. integer values - it makes no sense to request a range between two
            strings)  In query mode, this flag can accept a value.
        
        - streamName : stn               (unicode)       [create,query]
            Name of the metadata Stream. Depending on context it could be the name of a
            Stream to be created, or the name of the Stream to pass through the filter. In
            query mode, this flag can accept a value.Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        - stringValue : sv               (unicode)       [create]
            String value to be set into the specified metadata locations. This flag can only
            be used when the data member is a numeric type. If the member has N dimensions
            (e.g. string[2]) then this flag must appear N times (e.g. 2 times) The same
            values are applied to the specified metadata member on all affected components
            or metadata indices. Only one of the value, and stringValue flags can be
            specified at once and the type must match the type of the structure member named
            by the memberflag.
        
        - value : v                      (float)         [create]
            Numeric value to be set into the specified metadata locations. This flag can
            only be used when the data member is a numeric type. If the member has N
            dimensions (e.g. float[3]) then this flag must appear N times (e.g. 3 times) The
            same values are applied to the specified metadata member on all affected
            components or metadata indices. All numeric member types should use this type of
            value specification, i.e. everything except string and matrix types. Only one of
            the value, and stringValue flags can be specified at once and the type must
            match the type of the structure member named by the memberflag.
        
        
        Derived from mel command `maya.cmds.editMetadata`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ParticleColorMapper(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderLayer(DependNode):
    def addAdjustments(self, members): pass
    def addMembers(self, members, noRecurse='True'): pass
    def adjustmentPlug(self, scenePlug):
        """
        Returns the render layer adjustment value plug for the specified plug. If there is no layer override on the plug, a copy of scenePlug is returned.
        
        Parameters:
        scenePlug : 'PyNode'
            The plug for which the adjustment is sought.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.adjustmentPlug`
        """
        pass
    def externalRenderPasses(self):
        """
        The function builds an array of unique render pass nodes (MObject) that are connected to the renderPass attribute. This function descends recursively into render pass sets to collect all connected render passes.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.externalRenderPasses`
        """
        pass
    def inCurrentRenderLayer(self, objectPath):
        """
        The function checks if the given object is present in the current render layer or not.
        
        Parameters:
        objectPath : 'PyNode'
            Path of the render layer object.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.inCurrentRenderLayer`
        """
        pass
    def inLayer(self, transform):
        """
        Returns true if the given shape is in this layer. This method will check all container layers for transform containment. The MObject specified must be a shape node.
        
        Parameters:
        transform : 'PyNode'
            MObject of the shape we are testing against.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.inLayer`
        """
        pass
    def isPlugAdjusted(self, scenePlug):
        """
        The function checks if the specified plug is adjusted or not; returns true if the plug is adjusted, else returns false.
        
        Parameters:
        scenePlug : 'PyNode'
            The plug which needs to be checked for adjustment.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.isPlugAdjusted`
        """
        pass
    def layerChildren(self, recurse='False'):
        """
        Returns the container layers for this layer. Container layers provide the ability for a given render layer to "contain" other render layers.
        
        Parameters:
        recurse : 'bool'
            If true then the list operation will be applied recursively to any contained render layers which themselves contain other render layers.
        
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.layerChildren`
        """
        pass
    def listAdjustments(self): pass
    def listMembers(self, fullNames='True'): pass
    def passHasLight(self, renderPass, light):
        """
        Returns true if the specified light contributes to the given render pass, based on the pass contribution maps attached to this layer. This method does not verify whether the light or the renderPass are actually rendered by the layer.
        
        Parameters:
        renderPass : 'PyNode'
            a render pass node
        light : 'PyNode'
            a light shape node
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.passHasLight`
        """
        pass
    def passHasObject(self, renderPass, objectInstance):
        """
        Returns true if the specified object instance contributes to the given render pass, based on the pass contribution maps attached to the layer. This method does not verify whether the object instance or the renderPass are actually rendered by the layer.
        
        Parameters:
        renderPass : 'PyNode'
            a render pass node
        objectInstance : 'PyNode'
            DAG path of a shape instance
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.passHasObject`
        """
        pass
    def removeAdjustments(self, members): pass
    def removeMembers(self, members): pass
    def setCurrent(self): pass
    @classmethod
    def currentLayer(self):
        """
        Returns the MObject for the current render layer. This MObject can be used in MFnRenderLayer.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.currentLayer`
        """
        pass
    @classmethod
    def defaultRenderLayer(self):
        """
        Returns the MObject for the defaultRenderLayer. This MObject can be used in MFnRenderLayer.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.defaultRenderLayer`
        """
        pass
    @classmethod
    def findLayerByName(self, renderLayer):
        """
        This function returns an MObject to a render layer that matches the specified name. If no render layer is found with the given name, MObject::kNullObj is returned.
        
        Parameters:
        renderLayer : 'unicode'
            The name of the render layer.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.findLayerByName`
        """
        pass
    @classmethod
    def listAllRenderLayers(self):
        """
        Returns the list of render layers currently in the system.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaRender.MFnRenderLayer.listAllRenderLayers`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a new render layer.  The render layer number will be assigned based on
        the first unassigned number not less than the base index number found in the
        render layer global parameters.  Normally all objects and their descendants will
        be added to the new render layer but if '-noRecurse' is specified then only the
        objects themselves will be added. Only transforms and geometry will be added to
        the new render layer.
        
        Flags:
        - empty : e                      (bool)          [create]
            If set then create an empty render layer. The global flag or specified member
            list will take precidence over  use of this flag.
        
        - g : g                          (bool)          [create]
            If set then create a layer that contains all DAG objects in the scene. Any
            future objects created will also automatically become members of this layer. The
            global flag will take precidence over use of the empty flag or specified member
            list.
        
        - makeCurrent : mc               (bool)          [create]
            If set then make the new render layer the current one.
        
        - name : n                       (unicode)       [create]
            Name of the new render layer being created.
        
        - noRecurse : nr                 (bool)          [create]
            If set then only add specified objects to the render layer.  Otherwise all
            descendants will also be added.
        
        - number : num                   (int)           [create]
            Number for the new render layer being created.                             Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.createRenderLayer`
        """
        pass
    @staticmethod
    def __new__(cls, *args, **kwargs): pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'createRenderLayer'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GammaCorrect(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeWarp(DependNode):
    def deleteFrame(self, val='True', **kwargs):
        """
        The flag value indicates the 0-based index of the warp frame to delete. This flag can only be used in edit mode.                                   
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def getFrame(self, **kwargs):
        """
        In create and edit mode, this flag can be used to specify warp frames added to the warp operation. In query mode, this flag returns a list of the frame values where warping occurs. The moveFrame flag command can be used to query the associated warped values.                                 
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def getG(self, **kwargs):
        """
        In create mode, creates a global time warp node which impacts every animated object in the scene. In query mode, returns the global time warp node. Note: only one global time warp can exist in the scene.                                
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def getInterpType(self, **kwargs):
        """
        This flag can be used to set the interpolation type for a given span. Valid interpolation types are linear, easeIn and easeOut. When queried, it returns a string array of the interpolation types for the specified time warp.                                    
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def getMoveFrame(self, **kwargs):
        """
        This flag can be used to move a singular warp frame. The first value specified indicates the 0-based index of the warp frame to move. The second value indicates the new warp frame value. This flag can only be used in edit and query mode. When queried, it returns an array of the warped frame values.                                Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def setFrame(self, val='True', **kwargs):
        """
        In create and edit mode, this flag can be used to specify warp frames added to the warp operation. In query mode, this flag returns a list of the frame values where warping occurs. The moveFrame flag command can be used to query the associated warped values.                                 
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def setG(self, val='True', **kwargs):
        """
        In create mode, creates a global time warp node which impacts every animated object in the scene. In query mode, returns the global time warp node. Note: only one global time warp can exist in the scene.                                
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def setInterpType(self, val='True', **kwargs):
        """
        This flag can be used to set the interpolation type for a given span. Valid interpolation types are linear, easeIn and easeOut. When queried, it returns a string array of the interpolation types for the specified time warp.                                    
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    def setMoveFrame(self, val='True', **kwargs):
        """
        This flag can be used to move a singular warp frame. The first value specified indicates the 0-based index of the warp frame to move. The second value indicates the new warp frame value. This flag can only be used in edit and query mode. When queried, it returns an array of the warped frame values.                                Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create a time warp input to a set of animation curves.
        
        Flags:
        - deleteFrame : df               (int)           [edit]
            The flag value indicates the 0-based index of the warp frame to delete. This
            flag can only be used in edit mode.
        
        - frame : f                      (float)         [create,query,edit]
            In create and edit mode, this flag can be used to specify warp frames added to
            the warp operation. In query mode, this flag returns a list of the frame values
            where warping occurs. The moveFrame flag command can be used to query the
            associated warped values.
        
        - g : g                          (bool)          [create,query,edit]
            In create mode, creates a global time warp node which impacts every animated
            object in the scene. In query mode, returns the global time warp node. Note:
            only one global time warp can exist in the scene.
        
        - interpType : it                (int, unicode)  [create,query,edit]
            This flag can be used to set the interpolation type for a given span. Valid
            interpolation types are linear, easeIn and easeOut. When queried, it returns a
            string array of the interpolation types for the specified time warp.
        
        - moveFrame : mf                 (int, float)    [query,edit]
            This flag can be used to move a singular warp frame. The first value specified
            indicates the 0-based index of the warp frame to move. The second value
            indicates the new warp frame value. This flag can only be used in edit and query
            mode. When queried, it returns an array of the warped frame values.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.timeWarp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GeometryFilter(DependNode):
    def deformerSet(self):
        """
        Returns the set containing the objects that are deformed. Adding new components to the deformer set will cause them to be deformed. Removing components from the deformer set will prevent them from being influenced by the deformer.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.deformerSet`
        """
        pass
    def getEnvelope(self):
        """
        Returns the envelope value.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.envelope`
        """
        pass
    def getInputGeometry(self):
        """
        This method returns the input geometry for the deformer by traversing the graph to find upstream shape nodes. It is possible for there to be nodes in between the shape and the deformer so that the returned shape may have a different topology or tweaks then the input data to the deformer. If the actual input geometry data for the deformer is required, this information can be accessed by using MPlug::getValue() to query the inputGeometry attribute on the deformer.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.getInputGeometry`
        """
        pass
    def getOutputGeometry(self):
        """
        The output geometry is packed into the provided list of MObjects. Each of the MObjects will be a DAG node.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.getOutputGeometry`
        """
        pass
    def getPathAtIndex(self, index):
        """
        The DAG path of the output geometry at the specified plug index is put in the dagPath argument.
        
        Parameters:
        index : 'int'
            the plug index
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.getPathAtIndex`
        """
        pass
    def groupIdAtIndex(self, index):
        """
        Returns the groupId at the specified plug index.
        
        Parameters:
        index : 'int'
            the plug index for which the groupId is requested
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.groupIdAtIndex`
        """
        pass
    def indexForGroupId(self, groupId):
        """
        Returns the plug index corresponding to the groupId.
        
        Parameters:
        groupId : 'int'
            the groupId for the plug index
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.indexForGroupId`
        """
        pass
    def indexForOutputConnection(self, connectionIndex):
        """
        Returns the plug index corresponding to the connection index. The connection index is the index specifying the nth output connection. The plug index (logical index) is the sparse array index used by many of MFnGeometryFilter's methods and in MEL scripts. The connection index is 0-based, hence, the maximum value of the connection index is numOutputs - 1.
        
        Parameters:
        connectionIndex : 'int'
            the connection index
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.indexForOutputConnection`
        """
        pass
    def indexForOutputShape(self, shape):
        """
        Returns the plug index for the specified output shape.
        
        Parameters:
        shape : 'PyNode'
            the shape for which the plug index is requested
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.indexForOutputShape`
        """
        pass
    def inputShapeAtIndex(self, index):
        """
        Returns the input shape corresponding to the plug index.
        
        Parameters:
        index : 'int'
            the plug index for the input shape
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.inputShapeAtIndex`
        """
        pass
    def numOutputConnections(self):
        """
        Returns the number of output geometries connected to this node. This is typically equal to the number of input geometries unless an input or output geometry has been deleted, or a connection to an input or output geometry has been broken.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.numOutputConnections`
        """
        pass
    def outputShapeAtIndex(self, index):
        """
        Returns the output shape corresponding to the plug index
        
        Parameters:
        index : 'int'
            the plug index for the output shape
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.outputShapeAtIndex`
        """
        pass
    def setEnvelope(self, envelope):
        """
        Sets the envelope value.
        
        Parameters:
        envelope : 'float'
            envelope value
        
        Derived from api method `maya.OpenMayaAnim.MFnGeometryFilter.setEnvelope`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Flow(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getDivisions(self, **kwargs):
        """
        This flag specifies the number of lattice slices in x,y,z.The default values are 2 5 2.When queried, it returns the uint32_t uint32_t uint32_t
        
        
        Derived from mel command `maya.cmds.flow`
        """
        pass
    def getLocalCompute(self, **kwargs):
        """
        This flag specifies whether or not to have local control over the object deformation.Default value: is on when the lattice is around the curve, and is off when the lattice is around the object. When queried, it returns a boolean
        
        
        Derived from mel command `maya.cmds.flow`
        """
        pass
    def getLocalDivisions(self, **kwargs):
        """
        This flag specifies the extent of the region of effect.Default values are 2 2 2.When queried, it returns the uint32_t uint32_t uint32_t
        
        
        Derived from mel command `maya.cmds.flow`
        """
        pass
    def getObjectCentered(self, **kwargs):
        """
        This flag specifies whether to create the lattice around the selected object at its center, or to create the lattice around the curve.Default value is true.When queried, it returns a booleanFlag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.flow`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The flow command creates a deformation lattice to `bend' the object that is
        animated along a curve of a motion path animation. The motion path animation has
        to have the follow option set to be on.
        
        Flags:
        - divisions : dv                 (int, int, int) [query]
            This flag specifies the number of lattice slices in x,y,z.The default values are
            2 5 2.When queried, it returns the uint32_t uint32_t uint32_t
        
        - localCompute : lc              (bool)          [query]
            This flag specifies whether or not to have local control over the object
            deformation.Default value: is on when the lattice is around the curve, and is
            off when the lattice is around the object. When queried, it returns a boolean
        
        - localDivisions : ld            (int, int, int) [query]
            This flag specifies the extent of the region of effect.Default values are 2 2
            2.When queried, it returns the uint32_t uint32_t uint32_t
        
        - objectCentered : oc            (bool)          [query]
            This flag specifies whether to create the lattice around the selected object at
            its center, or to create the lattice around the curve.Default value is true.When
            queried, it returns a booleanFlag can have multiple arguments, passed either as
            a tuple or a list.
        
        
        Derived from mel command `maya.cmds.flow`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CacheBase(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class SimpleTestNode(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class UnitToTimeConversion(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ProxyManager(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DynGlobals(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getActive(self, **kwargs):
        """
        This flag returns the name of the active dynGlobals node in the the scene.  Only one dynGlobals node is active. It is the first on created.  Any additional dynGlobals nodes will be ignored.                  
        
        
        Derived from mel command `maya.cmds.dynGlobals`
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getListAll(self, **kwargs):
        """
        This flag will list all of the dynGlobals nodes in the scene.                  
        
        
        Derived from mel command `maya.cmds.dynGlobals`
        """
        pass
    def getOverSampling(self, **kwargs):
        """
        This flag will set the current overSampling value for all of the particle in the scene.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.dynGlobals`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setOverSampling(self, val='True', **kwargs):
        """
        This flag will set the current overSampling value for all of the particle in the scene.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.dynGlobals`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This node edits and queries the attributes of the active dynGlobals node in the
        scene. There can be only one active node of this type. The active dynGlobals
        node is the first one that was created, either with a createNodecommand or by
        accessing/editing any of the attributes on the node through this command.
        
        Flags:
        - active : a                     (bool)          [query]
            This flag returns the name of the active dynGlobals node in the the scene.  Only
            one dynGlobals node is active. It is the first on created.  Any additional
            dynGlobals nodes will be ignored.
        
        - listAll : la                   (bool)          [query]
            This flag will list all of the dynGlobals nodes in the scene.
        
        - overSampling : os              (int)           [query,edit]
            This flag will set the current overSampling value for all of the particle in the
            scene.                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.dynGlobals`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TexLattice(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Network(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CameraSet(DependNode):
    def appendLayer(self, camera, set):
        """
        Appends a layer to the associated cameraSet node. The given camera and object set are used in the layer. If MObject::kNullObj is passed as the set, then the whole scene will be rendered in the layer.
        
        Parameters:
        camera : 'PyNode'
            The camera or stereo rig for the layer
        set : 'PyNode'
            The set of objects used in the layer
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.appendLayer`
        """
        pass
    def appendTo(self, val='True', **kwargs):
        """
        Append a new camera and/or object set to then end of the cameraSet layer list. This flag cannot be used in conjunction with insert flag. Additionally, it requires the camera and/or objectSet flag to be used.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def clear(self):
        """
        Clear all of the camera layers.
        Derived from api method `maya.OpenMaya.MFnCameraSet.clear`
        """
        pass
    def deleteAll(self, val='True', **kwargs):
        """
        Delete all camera layers                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def deleteLayer(self, index):
        """
        Deletes the layer denoted by the given index.
        
        Parameters:
        index : 'int'
            The index of the layer
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.deleteLayer`
        """
        pass
    def getActive(self, **kwargs):
        """
        Gets / sets the active camera layer.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def getCamera(self, **kwargs):
        """
        Set/get the camera for a particular layer. When in query mode, You must specify the layer with the layer flag.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def getClearDepth(self, **kwargs):
        """
        Specifies if the drawing buffer should be cleared before beginning the draw for that layer.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def getLayer(self, **kwargs):
        """
        Specifies the layer index to be used when accessing layer information                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def getLayerCamera(self, index):
        """
        Get the camera used for a particular layer.
        
        Parameters:
        index : 'int'
            The index of the layer
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.getLayerCamera`
        """
        pass
    def getLayerClearDepthValue(self, index):
        """
        This method gets the clearDepth attribute value for the specified camera layer
        
        Parameters:
        index : 'int'
            The index of the layer
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.getLayerClearDepthValue`
        """
        pass
    def getLayerOrder(self, index):
        """
        Get the processing order of a particular layer.
        
        Parameters:
        index : 'int'
            The index of the layer
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.getLayerOrder`
        """
        pass
    def getLayerSceneData(self, index):
        """
        Get the scene data used for a particular layer. The returned scene data could be MObject::kNullObj if no scene data has been set. The operation will still be deemed successful.
        
        Parameters:
        index : 'int'
            The index of the layer
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.getLayerSceneData`
        """
        pass
    def getNumLayers(self):
        """
        Return the number of layers in the cameraSet.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.getNumLayers`
        """
        pass
    def getObjectSet(self, **kwargs):
        """
        Set/get the objectSet for a particular layer. When in query mode, you must specify the layer with the layer flag.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def getOrder(self, **kwargs):
        """
        Set the order in which a particular layer is processed. This flag must be used in conjunction with the layer flag.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def insertAt(self, val='True', **kwargs):
        """
        Inserts the specified camera and/or object set at the specified layer. This flag cannot be used in conjunction with the append flag. Additionally, this flag requires layer and camera (or objectSet) flag to be used.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def insertLayer(self, index, camera, set):
        """
        Inserts a layer at the given index to the associated cameraSet node using the given camera. The index value must be in the range from 0 to the number of layers currently defined. The given camera and object set are used in the layer. If MObject::kNullObj is passed as the set, then the whole scene will be rendered in the layer.
        
        Parameters:
        index : 'int'
            The index of the layer
        camera : 'PyNode'
            The camera for the layer
        set : 'PyNode'
            The set of objects used in the layer
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.insertLayer`
        """
        pass
    def isLayerActive(self, index):
        """
        Get whether a particular layer is active.
        
        Parameters:
        index : 'int'
            The index of the layer
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.isLayerActive`
        """
        pass
    def setActive(self, val='True', **kwargs):
        """
        Gets / sets the active camera layer.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def setCamera(self, val='True', **kwargs):
        """
        Set/get the camera for a particular layer. When in query mode, You must specify the layer with the layer flag.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def setClearDepth(self, val='True', **kwargs):
        """
        Specifies if the drawing buffer should be cleared before beginning the draw for that layer.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def setLayer(self, val='True', **kwargs):
        """
        Specifies the layer index to be used when accessing layer information                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def setLayerActive(self, index, isActive):
        """
        Set a particular layer to be active.
        
        Parameters:
        index : 'int'
            The index of the layer
        isActive : 'bool'
            Whether the layer should be processed
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.setLayerActive`
        """
        pass
    def setLayerCamera(self, index, camera):
        """
        Set the camera to be used for a particular layer.
        
        Parameters:
        index : 'int'
            The index of the layer
        camera : 'PyNode'
            The camera for the layer
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.setLayerCamera`
        """
        pass
    def setLayerClearDepthValue(self, index, depth):
        """
        This method sets the clearDepth attribute for the specified camera layer.
        
        Parameters:
        index : 'int'
            The index of the layer
        depth : 'bool'
            The clear depth value
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.setLayerClearDepthValue`
        """
        pass
    def setLayerOrder(self, index, order):
        """
        Set the processing order of a particular layer.
        
        Parameters:
        index : 'int'
            The index of the layer
        order : 'int'
            The order number
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.setLayerOrder`
        """
        pass
    def setLayerSceneData(self, index, set):
        """
        Set the scene data to be used for a particular layer.
        
        Parameters:
        index : 'int'
            The index of the layer
        set : 'PyNode'
            The object set for the layer
        
        Derived from api method `maya.OpenMaya.MFnCameraSet.setLayerSceneData`
        """
        pass
    def setObjectSet(self, val='True', **kwargs):
        """
        Set/get the objectSet for a particular layer. When in query mode, you must specify the layer with the layer flag.                  
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    def setOrder(self, val='True', **kwargs):
        """
        Set the order in which a particular layer is processed. This flag must be used in conjunction with the layer flag.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command manages camera set nodes. Camera sets allow the users to break a
        single camera shot into layers. Instead of drawing all objects with a single
        camera, you can isolate the camera to only focus on certain objects and layer
        another camera into the viewport that draws the other objects. The situation to
        use camera sets primarily occurs when building stereoscopic scenes. For example,
        a set of stereo parameters may make the background objects divergent beyond the
        tolerable range of the human perceptual system. However, you like the settings
        because the main focus is in the foreground and the depth is important to the
        visual look of the scene.  You can use camera sets to break apart the shot into
        a foreground stereo camera and background stereo camera. The foreground stereo
        camera will retain the original parameters; however, it will only focus on the
        foreground elements.  The background stereo camera will have a different set of
        stereo parameters and will only draw the background element. Camera sets can be
        viewed using the stereo viewer and are currently only designed to work with
        stereo camera rigs.
        
        Flags:
        - active : a                     (bool)          [create,query,edit]
            Gets / sets the active camera layer.
        
        - appendTo : atl                 (bool)          [create,edit]
            Append a new camera and/or object set to then end of the cameraSet layer list.
            This flag cannot be used in conjunction with insert flag. Additionally, it
            requires the camera and/or objectSet flag to be used.
        
        - camera : cam                   (unicode)       [create,query,edit]
            Set/get the camera for a particular layer. When in query mode, You must specify
            the layer with the layer flag.
        
        - clearDepth : cd                (bool)          [create,query,edit]
            Specifies if the drawing buffer should be cleared before beginning the draw for
            that layer.
        
        - deleteAll : da                 (bool)          [create,edit]
            Delete all camera layers
        
        - deleteLayer : d                (bool)          [create,edit]
            Delete a layer from the camera set. You must specify the layer using the layer
            flag.
        
        - insertAt : ins                 (bool)          [create,edit]
            Inserts the specified camera and/or object set at the specified layer. This flag
            cannot be used in conjunction with the append flag. Additionally, this flag
            requires layer and camera (or objectSet) flag to be used.
        
        - layer : l                      (int)           [create,query,edit]
            Specifies the layer index to be used when accessing layer information
        
        - name : n                       (unicode)       [create,query]
            Gets or sets the name for the created camera set.
        
        - numLayers : nl                 (bool)          [create,query]
            Returns the number of layers defined in the specified cameraSet
        
        - objectSet : os                 (unicode)       [create,query,edit]
            Set/get the objectSet for a particular layer. When in query mode, you must
            specify the layer with the layer flag.
        
        - order : o                      (int)           [create,query,edit]
            Set the order in which a particular layer is processed. This flag must be used
            in conjunction with the layer flag.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.cameraSet`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ShadingDependNode(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RemapValue(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class HwRenderGlobals(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class WtAddMatrix(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RgbToHsv(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Guide(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ClipToGhostData(DependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class SimpleVolumeShader(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ViewColorManager(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PrecompExport(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Brush(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlend(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderGlobals(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CameraView(DependNode):
    def addBookmark(self, val='True', **kwargs):
        """
        Associate this view with the camera specified or the camera in the active model panel. This flag can be used for creation or edit.                  
        
        
        Derived from mel command `maya.cmds.cameraView`
        """
        pass
    def animate(self, val='True', **kwargs):
        """
        Set the animation capability for view switches.                  
        
        
        Derived from mel command `maya.cmds.cameraView`
        """
        pass
    def camera(self, val='True', **kwargs):
        """
        Specify the camera to use. This flag should be used in conjunction with the add bookmark, remove bookmark, set camera, or set view flags. If this flag is not specified the camera in the active model panel will be used.                  
        
        
        Derived from mel command `maya.cmds.cameraView`
        """
        pass
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def removeBookmark(self, val='True', **kwargs):
        """
        Remove the association of this view with the camera specified or the camera in the active model panel. This can only be used with edit.                  
        
        
        Derived from mel command `maya.cmds.cameraView`
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    def setCamera(self, val='True', **kwargs):
        """
        Set this view into a camera specified by the camera flag or the camera in the active model panel. This flag can only be used with edit.                  
        
        
        Derived from mel command `maya.cmds.cameraView`
        """
        pass
    def setView(self, val='True', **kwargs):
        """
        Set the camera view to match a camera specified or the active model panel. This flag can only be used with edit.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cameraView`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a preset view for a camera which is then independent of the
        camera. The view stores a camera's eye point, center of interest point, up
        vector, tumble pivot, horizontal aperture, vertical aperature, focal length,
        orthographic width, and whether the camera is orthographic or perspective by
        default. Or you can only store 2D pan/zoom attributes by setting the
        bookmarkType to 1. These settings can be applied to any other camera through the
        set camera flag. This command can be used for creation or edit of camera view
        objects.  This command can only be executed with one of the add bookmark, or
        remove bookmark and one of set camera, or the set view flags set.
        
        Flags:
        - addBookmark : ab               (bool)          [create,edit]
            Associate this view with the camera specified or the camera in the active model
            panel. This flag can be used for creation or edit.
        
        - animate : an                   (bool)          [create,edit]
            Set the animation capability for view switches.
        
        - bookmarkType : typ             (int)           [create]
            Specify the bookmark type, which can be: 0. 3D bookmark; 1. 2D Pan/Zoom
            bookmark.
        
        - camera : c                     (PyNode)        [edit]
            Specify the camera to use. This flag should be used in conjunction with the add
            bookmark, remove bookmark, set camera, or set view flags. If this flag is not
            specified the camera in the active model panel will be used.
        
        - name : n                       (unicode)       [create]
            Set the name of the view. This flag can only be used for creation.
        
        - removeBookmark : rb            (bool)          [edit]
            Remove the association of this view with the camera specified or the camera in
            the active model panel. This can only be used with edit.
        
        - setCamera : sc                 (bool)          [edit]
            Set this view into a camera specified by the camera flag or the camera in the
            active model panel. This flag can only be used with edit.
        
        - setView : sv                   (bool)          [edit]
            Set the camera view to match a camera specified or the active model panel. This
            flag can only be used with edit.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.cameraView`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HardwareRenderingGlobals(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Condition(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DiskCache(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getAppend(self, **kwargs):
        """
        Append at the end and not to flush the existing cache                              
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getCacheType(self, **kwargs):
        """
        Specifies the type of cache to overwrite.  mcfpfor particle playback cache, mcfifor particle initial cache. mcjfor jiggle cache. This option is only activated during the cache creation.                                  
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getClose(self, **kwargs):
        """
        Close the cache given the disk cache node name.  If -eco/enabledCachesOnly is trueonly enabled disk cache nodes are affected.                              
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getCloseAll(self, **kwargs):
        """
        Close all disk cache files. If -eco/enabledCachesOnly is trueonly enabled disk cache nodes are affected.                                   
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def getDelete(self, **kwargs):
        """
        Delete the cache given the disk cache node name.  If -eco/enabledCachesOnly is trueonly enabled disk cache nodes are affected.                             
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getDeleteAll(self, **kwargs):
        """
        Delete all disk cache files.  If -eco/enabledCachesOnly is trueonly enabled disk cache nodes are affected.                                 
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getEmpty(self, **kwargs):
        """
        Clear the content of the disk cache with the given disk cache node name.  If -eco/enabledCachesOnly is trueonly enabled disk cache nodes are affected.                             
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getEmptyAll(self, **kwargs):
        """
        Clear the content of all disk caches.  If -eco/enabledCachesOnly is trueonly enabled disk cache nodes are affected.                                
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getEnabledCachesOnly(self, **kwargs):
        """
        When present, this flag restricts the -ea/emptyAll, so that only enableddisk caches (i.e., disk cache nodes with the .enableattribute set to true) are affected.                                   
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getEndTime(self, **kwargs):
        """
        Specifies the end frame of the cache range.                                
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getFrameRangeType(self, **kwargs):
        """
        Specifies the type of frame range to use, namely Render Globals, Time Slider, and Start/End.  In the case of Time Slider, startFrame and endFrame need to be specified.  (This flag is now obsolete.  Please use the -startTime and -endTime flags to specify the frame range explicitly.)                                 
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getOverSample(self, **kwargs):
        """
        Over sample if true. Otherwise, under sample.                              
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getSamplingRate(self, **kwargs):
        """
        Specifies how frequently to sample relative to each frame. When over-sampling (-overSample has been specified), this parameter determines how many times per frame the runup will be evaluated. When under-sampling (the default, when -overSample has not been specified), the runup will evaluate only once per srframes, where sris the value specified to this flag.                                   
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getStartTime(self, **kwargs):
        """
        Specifies the start frame of the cache range.                              
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def getTempDir(self, **kwargs):
        """
        Query-only flag for the location of temporary diskCache files.                             Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command to create, clear, or close disk cache(s).                In query mode,
        return type is based on queried flag.
        
        Flags:
        - append : a                     (bool)          [create,query]
            Append at the end and not to flush the existing cache
        
        - cacheType : ct                 (unicode)       [create,query]
            Specifies the type of cache to overwrite.  mcfpfor particle playback cache,
            mcfifor particle initial cache. mcjfor jiggle cache. This option is only
            activated during the cache creation.
        
        - close : c                      (unicode)       [create,query]
            Close the cache given the disk cache node name.  If -eco/enabledCachesOnly is
            trueonly enabled disk cache nodes are affected.
        
        - closeAll : ca                  (bool)          [create,query]
            Close all disk cache files. If -eco/enabledCachesOnly is trueonly enabled disk
            cache nodes are affected.
        
        - delete : d                     (unicode)       [create,query]
            Delete the cache given the disk cache node name.  If -eco/enabledCachesOnly is
            trueonly enabled disk cache nodes are affected.
        
        - deleteAll : da                 (bool)          [create,query]
            Delete all disk cache files.  If -eco/enabledCachesOnly is trueonly enabled disk
            cache nodes are affected.
        
        - empty : e                      (unicode)       [create,query]
            Clear the content of the disk cache with the given disk cache node name.  If
            -eco/enabledCachesOnly is trueonly enabled disk cache nodes are affected.
        
        - emptyAll : ea                  (bool)          [create,query]
            Clear the content of all disk caches.  If -eco/enabledCachesOnly is trueonly
            enabled disk cache nodes are affected.
        
        - enabledCachesOnly : eco        (bool)          [create,query]
            When present, this flag restricts the -ea/emptyAll, so that only enableddisk
            caches (i.e., disk cache nodes with the .enableattribute set to true) are
            affected.
        
        - endTime : et                   (time)          [create,query]
            Specifies the end frame of the cache range.
        
        - frameRangeType : frt           (unicode)       [create,query]
            Specifies the type of frame range to use, namely Render Globals, Time Slider,
            and Start/End.  In the case of Time Slider, startFrame and endFrame need to be
            specified.  (This flag is now obsolete.  Please use the -startTime and -endTime
            flags to specify the frame range explicitly.)
        
        - overSample : os                (bool)          [create,query]
            Over sample if true. Otherwise, under sample.
        
        - samplingRate : sr              (int)           [create,query]
            Specifies how frequently to sample relative to each frame. When over-sampling
            (-overSample has been specified), this parameter determines how many times per
            frame the runup will be evaluated. When under-sampling (the default, when
            -overSample has not been specified), the runup will evaluate only once per
            srframes, where sris the value specified to this flag.
        
        - startTime : st                 (time)          [create,query]
            Specifies the start frame of the cache range.
        
        - tempDir : tmp                  (bool)          [create,query]
            Query-only flag for the location of temporary diskCache files.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.diskCache`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdivReverseFaces(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Sampler(DependNode):
    def findAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions
        """
        pass
    def getAffectedAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affected instead.
        """
        pass
    def getAffectedByAttributes(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.affects instead.
        """
        pass
    def getAliasList(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use listAliases instead.
        """
        pass
    def getConnections(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use inputs/outputs, or general.listConnections instead.
        """
        pass
    def plugsAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.getAlias instead.
        """
        pass
    def setAlias(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use Attribute.setAlias instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatNegate(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PlanarTrimSurface(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class SubSurface(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiWriteFloat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmCurveToSpline(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeEnum(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class UseBackground(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMax(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleCreator(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GlobalStitch(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getLockSurface(self, **kwargs):
        """
        Keep the NURBS surface at the specified multi index unchanged by the fitting. Default:false                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getMaxSeparation(self, **kwargs):
        """
        Maximum separation that will still be stitched. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getModificationResistance(self, **kwargs):
        """
        Modification resistance weight for surface CVs. Default:1e-1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getSampling(self, **kwargs):
        """
        Sampling when stitching edges. Default:1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getStitchCorners(self, **kwargs):
        """
        Stitch corners of surfaces. 0 - off 1 - closest point 2 - closest knot Default:1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getStitchEdges(self, **kwargs):
        """
        Stitch edges of surfaces. 0 - off 1 - closest point 2 - matching params Default:1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getStitchPartialEdges(self, **kwargs):
        """
        Toggle on (off) partial edge stitching. Default:false                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def getStitchSmoothness(self, **kwargs):
        """
        Set type of smoothness of edge join. 0 - off 1 - tangent 2 - normal Default:0                  Common flags
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setLockSurface(self, val='True', **kwargs):
        """
        Keep the NURBS surface at the specified multi index unchanged by the fitting. Default:false                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setMaxSeparation(self, val='True', **kwargs):
        """
        Maximum separation that will still be stitched. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setModificationResistance(self, val='True', **kwargs):
        """
        Modification resistance weight for surface CVs. Default:1e-1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setSampling(self, val='True', **kwargs):
        """
        Sampling when stitching edges. Default:1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setStitchCorners(self, val='True', **kwargs):
        """
        Stitch corners of surfaces. 0 - off 1 - closest point 2 - closest knot Default:1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setStitchEdges(self, val='True', **kwargs):
        """
        Stitch edges of surfaces. 0 - off 1 - closest point 2 - matching params Default:1                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setStitchPartialEdges(self, val='True', **kwargs):
        """
        Toggle on (off) partial edge stitching. Default:false                  
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    def setStitchSmoothness(self, val='True', **kwargs):
        """
        Set type of smoothness of edge join. 0 - off 1 - tangent 2 - normal Default:0                  Common flags
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command computes a globalStitch of NURBS surfaces. There should be at least
        one  NURBS surface. The NURBS surface(s) should be untrimmed.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - lockSurface : lk               (bool)          [create,query,edit]
            Keep the NURBS surface at the specified multi index unchanged by the fitting.
            Default:false
        
        - maxSeparation : ms             (float)         [create,query,edit]
            Maximum separation that will still be stitched. Default:0.1
        
        - modificationResistance : mr    (float)         [create,query,edit]
            Modification resistance weight for surface CVs. Default:1e-1
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - replaceOriginal : rpo          (bool)          []
        
        - sampling : sam                 (int)           [create,query,edit]
            Sampling when stitching edges. Default:1
        
        - stitchCorners : sc             (int)           [create,query,edit]
            Stitch corners of surfaces. 0 - off 1 - closest point 2 - closest knot Default:1
        
        - stitchEdges : se               (int)           [create,query,edit]
            Stitch edges of surfaces. 0 - off 1 - closest point 2 - matching params
            Default:1
        
        - stitchPartialEdges : spe       (bool)          [create,query,edit]
            Toggle on (off) partial edge stitching. Default:false
        
        - stitchSmoothness : ss          (int)           [create,query,edit]
            Set type of smoothness of edge join. 0 - off 1 - tangent 2 - normal Default:0
            Common flags
        
        
        Derived from mel command `maya.cmds.globalStitch`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectGrpToComp(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Extrude(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getDegreeAlongLength(self, **kwargs):
        """
        Surface degree along the distance when a distance extrude is performed Default:1                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getDirection(self, **kwargs):
        """
        The direction in which to extrude. Use only for distance extrudeType and useProfileNormal off                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        X of the direction Default:0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        Y of the direction Default:1                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        Z of the direction Default:0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getExtrudeType(self, **kwargs):
        """
        The extrude type (distance-0, flat-1, or tube-2) Default:2                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getFixedPath(self, **kwargs):
        """
        If true, the resulting surface will be placed at the path curve. Otherwise, the resulting surface will be placed at the profile curve. Default:false                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getLength(self, **kwargs):
        """
        The distance to extrude. Use only for distance extrudeType Default:1                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The pivot point used for tube extrudeType                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getReverseSurfaceIfPathReversed(self, **kwargs):
        """
        If true, extrude type is tube (2) and path has been internally reversed then computed surface is reversed in the direction corresponding to the path. Default:false                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getRotation(self, **kwargs):
        """
        Amount to rotate the profile curve as it sweeps along the path curve. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getScale(self, **kwargs):
        """
        Amount to scale the profile curve as it sweeps along the path curve. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getSubCurveSubSurface(self, **kwargs):
        """
        If true, curve range on the path will get applied to the resulting surface instead of cut before the extrude. Default:false                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getUseComponentPivot(self, **kwargs):
        """
        Use closest endpoint of the path - 0, component pivot - 1 or the center of the bounding box of the profile - 2 Default:0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def getUseProfileNormal(self, **kwargs):
        """
        If true, use the profile curve normal for the direction in which to extrude. Use only for distance or tube extrudeType. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setDegreeAlongLength(self, val='True', **kwargs):
        """
        Surface degree along the distance when a distance extrude is performed Default:1                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        The direction in which to extrude. Use only for distance extrudeType and useProfileNormal off                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        X of the direction Default:0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        Y of the direction Default:1                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        Z of the direction Default:0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setExtrudeType(self, val='True', **kwargs):
        """
        The extrude type (distance-0, flat-1, or tube-2) Default:2                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setFixedPath(self, val='True', **kwargs):
        """
        If true, the resulting surface will be placed at the path curve. Otherwise, the resulting surface will be placed at the profile curve. Default:false                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setLength(self, val='True', **kwargs):
        """
        The distance to extrude. Use only for distance extrudeType Default:1                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The pivot point used for tube extrudeType                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setReverseSurfaceIfPathReversed(self, val='True', **kwargs):
        """
        If true, extrude type is tube (2) and path has been internally reversed then computed surface is reversed in the direction corresponding to the path. Default:false                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setRotation(self, val='True', **kwargs):
        """
        Amount to rotate the profile curve as it sweeps along the path curve. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        Amount to scale the profile curve as it sweeps along the path curve. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setSubCurveSubSurface(self, val='True', **kwargs):
        """
        If true, curve range on the path will get applied to the resulting surface instead of cut before the extrude. Default:false                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setUseComponentPivot(self, val='True', **kwargs):
        """
        Use closest endpoint of the path - 0, component pivot - 1 or the center of the bounding box of the profile - 2 Default:0                  
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    def setUseProfileNormal(self, val='True', **kwargs):
        """
        If true, use the profile curve normal for the direction in which to extrude. Use only for distance or tube extrudeType. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command computes a surface given a profile curve and possibly a path curve.
        There are three ways to extrude a profile curve. The most basic method is called
        a distanceextrude where direction and length are specified. No path curve is
        necessary in this case. The second method is called flatextrude. This method
        sweeps the profile curve down the path curve without changing the orientation of
        the profile curve. Finally, the third method is called tubeextrude. This method
        sweeps a profile curve down a path curve while the profile curve rotates so that
        it maintains a relationship with the path curve.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degreeAlongLength : dl         (int)           [create,query,edit]
            Surface degree along the distance when a distance extrude is performed Default:1
        
        - direction : d                  (float, float, float) [create,query,edit]
            The direction in which to extrude. Use only for distance extrudeType and
            useProfileNormal off
        
        - directionX : dx                (float)         [create,query,edit]
            X of the direction Default:0
        
        - directionY : dy                (float)         [create,query,edit]
            Y of the direction Default:1
        
        - directionZ : dz                (float)         [create,query,edit]
            Z of the direction Default:0
        
        - extrudeType : et               (int)           [create,query,edit]
            The extrude type (distance-0, flat-1, or tube-2) Default:2
        
        - fixedPath : fpt                (bool)          [create,query,edit]
            If true, the resulting surface will be placed at the path curve. Otherwise, the
            resulting surface will be placed at the profile curve. Default:false
        
        - frozen : fzn                   (bool)          []
        
        - length : l                     (float)         [create,query,edit]
            The distance to extrude. Use only for distance extrudeType Default:1
        
        - mergeItems : mi                (bool)          [create]
            Merge component results where possible. For example, instead of returning a[1]
            and a[2], return a[1:2].
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - pivot : p                      (float, float, float) [create,query,edit]
            The pivot point used for tube extrudeType
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.
        
        - rebuild : rb                   (bool)          [create]
            Rebuild the input curve(s) before using them in the operation.  Use
            nurbsCurveRebuildPref to set the parameters for the conversion.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        - reverseSurfaceIfPathReversed : rsp (bool)          [create,query,edit]
            If true, extrude type is tube (2) and path has been internally reversed then
            computed surface is reversed in the direction corresponding to the path.
            Default:false
        
        - rotation : ro                  (float)         [create,query,edit]
            Amount to rotate the profile curve as it sweeps along the path curve.
            Default:0.0
        
        - scale : sc                     (float)         [create,query,edit]
            Amount to scale the profile curve as it sweeps along the path curve. Default:1.0
        
        - subCurveSubSurface : scs       (bool)          [create,query,edit]
            If true, curve range on the path will get applied to the resulting surface
            instead of cut before the extrude. Default:false
        
        - useComponentPivot : ucp        (int)           [create,query,edit]
            Use closest endpoint of the path - 0, component pivot - 1 or the center of the
            bounding box of the profile - 2 Default:0
        
        - useProfileNormal : upn         (bool)          [create,query,edit]
            If true, use the profile curve normal for the direction in which to extrude. Use
            only for distance or tube extrudeType. Default:false                  Common
            flags
        
        
        Derived from mel command `maya.cmds.extrude`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUserDataBool(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RoundConstantRadius(AbstractBaseCreate):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command generates constant radius NURBS fillets and NURBS corner surfaces
        for matching edge pairs on NURBS surfaces.  An edge pair is a matching pair of
        surface isoparms or trim edges. This command can handle more than one edge pair
        at a time. This command can also handle compoundedges, which is where an edge
        pair is composed of more than two surfaces.  Use the -saand -sbflags in this
        case. The results from this command are three surface var groups plus the name
        of the new roundConstantRadius dependency node, if history was on. The 1st var
        group contains trimmed copies of the original surfaces.  The 2nd var group
        contains the new NURBS fillet surfaces.  The 3rd var group contains the new
        NURBS corners (if any). A simple example of an edge pair is an edge of a NURBS
        cube, where two faces of the cube meet.  This command generates a NURBS fillet
        at the edge and trims back the faces. Another example is a NURBS cylinder with a
        planar trim surface cap. This command will create a NURBS fillet where the cap
        meets the the cylinder and will trim back the cap and the cylinder. Another
        example involves all 12 edges of a NURBS cube.  NURBS fillets are created where
        any face meets another face.  NURBS corners are created whenever 3 edges meet at
        a corner.
        
        Flags:
        - append : a                     (bool)          [create]
            If true, then an edge pair is being added to an existing round dependency node.
            Default is false. When this flag is true, an existing round dependency node must
            be specified. See example below.
        
        - caching : cch                  (bool)          []
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           []
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - radius : r                     (float)         []
        
        - radiuss : rad                  (float)         [create]
            Use this flag to specify radius.  This overrides the r/radiusflag.  If only one
            radflag is used, then it is applied to all edge pairs.  If more than one radflag
            is used, then the number of -radflags must equal the number of edge pairs.  For
            example, for four edge pairs, zero, one or four radflags must be specified.
        
        - side : s                       (unicode, int)  [create]
            Use this flag for compound edges.  It replaces the sidea/sideb flags and is
            compatible with Python.  The first argument must be either aor b.  The same
            number of avalues as bvalues must be specified. If no sides are specified with
            the sideflag (or sidea/sideb flags), then the edges are assumed to be in pairs.
            See also examples below. For example, two faces of a cube meet at an edge pair.
            Suppose one of the faces is then split in two pieces at the middle of the edge,
            so that there is one face on side A, and two pieces on side B.  In this case the
            flag combination: -side a1 -side b2 would be used. The edges must be specified
            in the corresponding order: // MEL roundConstantRadius -side a1 -side b2 isoA
            isoB1 isoB2; # Python maya.cmds.roundConstantRadius( 'isoA', 'isoB1', 'isoB2',
            side=[(a,1), (b,2)] )
        
        - sidea : sa                     (int)           [create]
            Use this flag for compound edges in conjunction with the following -sbflag.
            This flag is not intended for use from Python.  Please see sideflag instead.
            The same number of -saflags as -sbflags must be specified. If no -sanor -sbflags
            are specified, then the edges are assumed to be in pairs. See also examples
            below. For example, two faces of a cube meet at an edge pair. Suppose one of the
            faces is then split in two pieces at the middle of the edge, so that there is
            one face on side A, and two pieces on side B.  In this case, the flag
            combination: -sidea 1 -sideb 2 would be used. The edges must be specified in the
            corresponding order: roundConstantRadius -sidea 1 -sideb 2 isoA isoB1 isoB2;
        
        - sideb : sb                     (int)           [create]
            Use this flag for compound edges in conjunction with the -saflag.  See
            description for the -saflag.  This flag is not intended for use from Python.
            Please see sideflag instead.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        - tolerance : tol                (float)         []
        
        
        Derived from mel command `maya.cmds.roundConstantRadius`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class IkSplineSolver(IkSolver):
    __melnode__ = []
    
    
    __readonly__ = {}


class ParticleCloud(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class NearestPointOnCurve(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class Trim(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def getLocatorU(self, **kwargs):
        """
        u parameter value to position a locator on the surface. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def getLocatorV(self, **kwargs):
        """
        v parameter value to position a locator on the surface. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def getSelected(self, **kwargs):
        """
        Specify whether to keep or discard selected regions. Default:0                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def getShrink(self, **kwargs):
        """
        If true, shrink underlying surface to outer boundaries of trimmed surface. Default:false                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to trim. Default:0.001                  Common flags
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def setLocatorU(self, val='True', **kwargs):
        """
        u parameter value to position a locator on the surface. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def setLocatorV(self, val='True', **kwargs):
        """
        v parameter value to position a locator on the surface. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def setSelected(self, val='True', **kwargs):
        """
        Specify whether to keep or discard selected regions. Default:0                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def setShrink(self, val='True', **kwargs):
        """
        If true, shrink underlying surface to outer boundaries of trimmed surface. Default:false                  
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to trim. Default:0.001                  Common flags
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command trims a surface to its curves on surface by first splitting the
        surface and then selecting which regions to keep or discard.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - locatorU : lu                  (float)         [create,query,edit]
            u parameter value to position a locator on the surface. Default:0.5
        
        - locatorV : lv                  (float)         [create,query,edit]
            v parameter value to position a locator on the surface. Default:0.5
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - replaceOriginal : rpo          (bool)          []
        
        - selected : sl                  (int)           [create,query,edit]
            Specify whether to keep or discard selected regions. Default:0
        
        - shrink : sh                    (bool)          [create,query,edit]
            If true, shrink underlying surface to outer boundaries of trimmed surface.
            Default:false
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to trim. Default:0.001                  Common flags
        
        
        Derived from mel command `maya.cmds.trim`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiNormalMap(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiIsFinite(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Unpremultiply(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySuperShape(THdependNode):
    """
    class counterpart of mel function `polySuperShape`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - createUV : uv                  (int)           []
        
        - ellipseMirror : em             (bool)          []
        
        - hExponent : he                 (float)         []
        
        - hExponent1 : he1               (float)         []
        
        - hExponent2 : he2               (float)         []
        
        - hMultiplier1 : hm1             (float)         []
        
        - hMultiplier2 : hm2             (float)         []
        
        - hUltraExponent1 : u1           (float)         []
        
        - hUltraExponent2 : u2           (float)         []
        
        - hUltraExponent3 : u5           (float)         []
        
        - hUltraExponent4 : u6           (float)         []
        
        - hUltraExponent5 : u7           (float)         []
        
        - hUltraMixer : u3               (float)         []
        
        - hUltraMultiplier1 : u0         (float)         []
        
        - hUltraMultiplier2 : u4         (float)         []
        
        - horizontalDivisions : hd       (int)           []
        
        - horizontalRevolutions : hr     (float)         []
        
        - internalRadius : ir            (float)         []
        
        - mergeVertices : mv             (bool)          []
        
        - radius : r                     (float)         []
        
        - shape : s                      (unicode)       []
        
        - ultraMirror : um               (bool)          []
        
        - vExponent : ve                 (float)         []
        
        - vExponent1 : ve1               (float)         []
        
        - vExponent2 : ve2               (float)         []
        
        - vMultiplier1 : vm1             (float)         []
        
        - vMultiplier2 : vm2             (float)         []
        
        - vUltraExponent1 : u9           (float)         []
        
        - vUltraExponent2 : u10          (float)         []
        
        - vUltraExponent3 : u13          (float)         []
        
        - vUltraExponent4 : u14          (float)         []
        
        - vUltraExponent5 : u15          (float)         []
        
        - vUltraMixer : u11              (float)         []
        
        - vUltraMultiplier1 : u8         (float)         []
        
        - vUltraMultiplier2 : u12        (float)         []
        
        - verticalDivisions : vd         (int)           []
        
        - verticalOffset : vo            (float)         []
        
        - verticalRevolutions : vr       (float)         []
        
        - xOffset : xo                   (float)         []
        
        - zOffset : zo                   (float)         []
        
        
        Derived from mel command `maya.cmds.polySuperShape`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BossWaveSolver(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AlembicNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BirailSrf(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AdskMaterial(TadskAssetInstanceNode_TdependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class Cryptomatte(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiDisable(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RampShader(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class PointOnCurveInfo(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKPinning2State(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAdd(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorCorrect(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FfFilletSrf(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromMeshEdge(CurveFromMesh):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiModulo(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatConjugate(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKFK2State(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NurbsCurveToBezier(AbstractBaseCreate):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The nurbsCurveToBezier command attempts to convert an existing NURBS curve to a
        Bezier curve.
        
        
        Derived from mel command `maya.cmds.nurbsCurveToBezier`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSetTransform(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HistorySwitch(GeometryFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiVectorMap(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiDivide(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiNegate(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class VolumeFog(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCompare(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Unfold3DUnfold(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectAttrFilter(ObjectFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class THcameraSet(CameraSet):
    __melnode__ = []
    
    
    __readonly__ = {}


class ClosestPointOnSurface(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AlignCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getCurvatureContinuity(self, **kwargs):
        """
        Curvature continuity is on if true and off otherwise. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getCurvatureScale1(self, **kwargs):
        """
        Curvature scale applied to curvature of first curve for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getCurvatureScale2(self, **kwargs):
        """
        Curvature scale applied to curvature of second curve for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getJoinParameter(self, **kwargs):
        """
        Parameter on reference curve where modified curve is to be aligned to. Default:123456.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getPositionalContinuity(self, **kwargs):
        """
        Positional continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getPositionalContinuityType(self, **kwargs):
        """
        Positional continuity type legal values: 1 - move first curve, 2 - move second curve, 3 - move both curves, 4 - modify first curve, 5 - modify second curve, 6 - modify both curves Default:1                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getReverse1(self, **kwargs):
        """
        If true, reverse the first input curve before doing align. Otherwise, do nothing to the first input curve before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getReverse2(self, **kwargs):
        """
        If true, reverse the second input curve before doing align. Otherwise, do nothing to the second input curve before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getTangentContinuity(self, **kwargs):
        """
        Tangent continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getTangentContinuityType(self, **kwargs):
        """
        Tangent continuity type legal values: 1 - do tangent continuity on first curve, 2 - do tangent continuity on second curve Default:1                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getTangentScale1(self, **kwargs):
        """
        Tangent scale applied to tangent of first curve for tangent continuity. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def getTangentScale2(self, **kwargs):
        """
        Tangent scale applied to tangent of second curve for tangent continuity. Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setCurvatureContinuity(self, val='True', **kwargs):
        """
        Curvature continuity is on if true and off otherwise. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setCurvatureScale1(self, val='True', **kwargs):
        """
        Curvature scale applied to curvature of first curve for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setCurvatureScale2(self, val='True', **kwargs):
        """
        Curvature scale applied to curvature of second curve for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setJoinParameter(self, val='True', **kwargs):
        """
        Parameter on reference curve where modified curve is to be aligned to. Default:123456.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setPositionalContinuity(self, val='True', **kwargs):
        """
        Positional continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setPositionalContinuityType(self, val='True', **kwargs):
        """
        Positional continuity type legal values: 1 - move first curve, 2 - move second curve, 3 - move both curves, 4 - modify first curve, 5 - modify second curve, 6 - modify both curves Default:1                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setReverse1(self, val='True', **kwargs):
        """
        If true, reverse the first input curve before doing align. Otherwise, do nothing to the first input curve before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setReverse2(self, val='True', **kwargs):
        """
        If true, reverse the second input curve before doing align. Otherwise, do nothing to the second input curve before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setTangentContinuity(self, val='True', **kwargs):
        """
        Tangent continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setTangentContinuityType(self, val='True', **kwargs):
        """
        Tangent continuity type legal values: 1 - do tangent continuity on first curve, 2 - do tangent continuity on second curve Default:1                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setTangentScale1(self, val='True', **kwargs):
        """
        Tangent scale applied to tangent of first curve for tangent continuity. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    def setTangentScale2(self, val='True', **kwargs):
        """
        Tangent scale applied to tangent of second curve for tangent continuity. Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The curve align command is used to align curves in maya. The main alignment
        options are positional, tangent and curvature continuity. Curvature continuity
        implies tangent continuity. Positional continuity means the curves (move) or the
        ends of the curves (modify) are changed. Tangent continuity means one of the
        curves is modified to be tangent at the points where they meet. Curvature
        continuity means one of the curves is modified to be curvature continuous as
        well as tangent. The default behaviour, when no curves or flags are passed, is
        to only do positional and tangent continuity on the active list with the end of
        the first curve and the start of the other curve used for alignment.
        
        Flags:
        - attach : at                    (bool)          [create]
            True if the curve is to be attached
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curvatureContinuity : cc       (bool)          [create,query,edit]
            Curvature continuity is on if true and off otherwise. Default:false
        
        - curvatureScale1 : cs1          (float)         [create,query,edit]
            Curvature scale applied to curvature of first curve for curvature continuity.
            Default:0.0
        
        - curvatureScale2 : cs2          (float)         [create,query,edit]
            Curvature scale applied to curvature of second curve for curvature continuity.
            Default:0.0
        
        - frozen : fzn                   (bool)          []
        
        - joinParameter : jnp            (float)         [create,query,edit]
            Parameter on reference curve where modified curve is to be aligned to.
            Default:123456.0
        
        - keepMultipleKnots : kmk        (bool)          [create]
            True if multiple knots should be left as-is.
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - positionalContinuity : pc      (bool)          [create,query,edit]
            Positional continuity is on if true and off otherwise. Default:true
        
        - positionalContinuityType : pct (int)           [create,query,edit]
            Positional continuity type legal values: 1 - move first curve, 2 - move second
            curve, 3 - move both curves, 4 - modify first curve, 5 - modify second curve, 6
            - modify both curves Default:1
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - reverse1 : rv1                 (bool)          [create,query,edit]
            If true, reverse the first input curve before doing align. Otherwise, do nothing
            to the first input curve before aligning. NOTE: setting this attribute to random
            values will cause unpredictable results and is not supported. Default:false
        
        - reverse2 : rv2                 (bool)          [create,query,edit]
            If true, reverse the second input curve before doing align. Otherwise, do
            nothing to the second input curve before aligning. NOTE: setting this attribute
            to random values will cause unpredictable results and is not supported.
            Default:false
        
        - tangentContinuity : tc         (bool)          [create,query,edit]
            Tangent continuity is on if true and off otherwise. Default:true
        
        - tangentContinuityType : tct    (int)           [create,query,edit]
            Tangent continuity type legal values: 1 - do tangent continuity on first curve,
            2 - do tangent continuity on second curve Default:1
        
        - tangentScale1 : ts1            (float)         [create,query,edit]
            Tangent scale applied to tangent of first curve for tangent continuity.
            Default:1.0
        
        - tangentScale2 : ts2            (float)         [create,query,edit]
            Tangent scale applied to tangent of second curve for tangent continuity.
            Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.alignCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleShader(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMixShader(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Sculpt(GeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getDropoffDistance(self, **kwargs):
        """
        Specifies the distance from the surface of the sculpt object at which the sculpt object produces no deformation effect. Default is 1.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getDropoffType(self, **kwargs):
        """
        Specifies how the deformation effect drops off from maximum effect at the surface of the sculpt object to no effect at dropoff distance limit. Valid values are: linear | none. Default is linear. When queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getInsideMode(self, **kwargs):
        """
        Specifies how the deformation algorithm deals with points that are inside the sculpting primitve. The choices are: ring | even. The default is even. When queried, this flag returns a string. Ring mode will tend to produce a contour like ring of points around the sculpt object as it passes through an object while even mode will try to spread the points out as evenly as possible across the surface of the sculpt object.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getMaxDisplacement(self, **kwargs):
        """
        Defines the maximum amount the sculpt object may move a point on an object which it is deforming. Default is 1.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def getMode(self, **kwargs):
        """
        Specifies which deformation algorithm the sculpt object should use. The choices are: flip | project | stretch. The default is stretch. When queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def setDropoffDistance(self, val='True', **kwargs):
        """
        Specifies the distance from the surface of the sculpt object at which the sculpt object produces no deformation effect. Default is 1.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def setDropoffType(self, val='True', **kwargs):
        """
        Specifies how the deformation effect drops off from maximum effect at the surface of the sculpt object to no effect at dropoff distance limit. Valid values are: linear | none. Default is linear. When queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def setInsideMode(self, val='True', **kwargs):
        """
        Specifies how the deformation algorithm deals with points that are inside the sculpting primitve. The choices are: ring | even. The default is even. When queried, this flag returns a string. Ring mode will tend to produce a contour like ring of points around the sculpt object as it passes through an object while even mode will try to spread the points out as evenly as possible across the surface of the sculpt object.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def setMaxDisplacement(self, val='True', **kwargs):
        """
        Defines the maximum amount the sculpt object may move a point on an object which it is deforming. Default is 1.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    def setMode(self, val='True', **kwargs):
        """
        Specifies which deformation algorithm the sculpt object should use. The choices are: flip | project | stretch. The default is stretch. When queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a sculpt object deformer. By default for
        creation mode an implicit sphere will be used as the sculpting object if no
        sculpt tool is specified. The name of the created/edited object is returned.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - dropoffDistance : dds          (float)         [create,query,edit]
            Specifies the distance from the surface of the sculpt object at which the sculpt
            object produces no deformation effect. Default is 1.0. When queried, this flag
            returns a float.
        
        - dropoffType : drt              (unicode)       [create,query,edit]
            Specifies how the deformation effect drops off from maximum effect at the
            surface of the sculpt object to no effect at dropoff distance limit. Valid
            values are: linear | none. Default is linear. When queried, this flag returns a
            string.
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - groupWithLocator : gwl         (bool)          [create]
            Groups the sculptor and its locator together under a single transform. Default
            is off.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - insideMode : im                (unicode)       [create,query,edit]
            Specifies how the deformation algorithm deals with points that are inside the
            sculpting primitve. The choices are: ring | even. The default is even. When
            queried, this flag returns a string. Ring mode will tend to produce a contour
            like ring of points around the sculpt object as it passes through an object
            while even mode will try to spread the points out as evenly as possible across
            the surface of the sculpt object.
        
        - maxDisplacement : mxd          (float)         [create,query,edit]
            Defines the maximum amount the sculpt object may move a point on an object which
            it is deforming. Default is 1.0. When queried, this flag returns a float.
        
        - mode : m                       (unicode)       [create,query,edit]
            Specifies which deformation algorithm the sculpt object should use. The choices
            are: flip | project | stretch. The default is stretch. When queried, this flag
            returns a string.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - objectCentered : oc            (bool)          [create]
            Places the sculpt and locator in the center of the bounding box of the selected
            object(s) or components. Default is off which centers the sculptor and locator
            at the origin.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - sculptTool : st                (unicode)       [create]
            Use the specified NURBS object as the sculpt tool instead of the default
            implicit sphere.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.sculpt`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyEdgeToCurve(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class MotionTrail(Snapshot):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStandardVolume(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Type(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BifrostAeroMaterial(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiBarndoor(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AvgNurbsSurfacePoints(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLayerShader(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiFloatToInt(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUserDataInt(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKSolverNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RebuildCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting curve 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getEndKnots(self, **kwargs):
        """
        End conditions for the curve 0 - uniform end knots, 1 - multiple end knots, Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getFitRebuild(self, **kwargs):
        """
        If true use the least squares fit rebuild. Otherwise use the convert method. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getKeepControlPoints(self, **kwargs):
        """
        If true, the CVs will remain the same. This forces uniform parameterization unless rebuildType is matchKnots. Default:false                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getKeepEndPoints(self, **kwargs):
        """
        If true, keep the endpoints the same. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getKeepRange(self, **kwargs):
        """
        Determine the parameterization for the resulting curve. 0 - reparameterize the resulting curve from 0 to 1, 1 - keep the original curve parameterization, 2 - reparameterize the result from 0 to number of spans Default:1                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getKeepTangents(self, **kwargs):
        """
        If true, keep the end tangents the same. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getRebuildType(self, **kwargs):
        """
        How to rebuild the input curve. 0 - uniform, 1 - reduce spans, 2 - match knots, 3 - remove multiple knots, 4 - curvature 5 - rebuild ends 6 - clean Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getSmartSurfaceCurveRebuild(self, **kwargs):
        """
        If true, curve on surface is rebuild in 3D and 2D info is kept Default:false                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getSpans(self, **kwargs):
        """
        The number of spans in resulting curve Used only if rebuildType is uniform. Default:4                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to rebuild. Default:0.01                  Common flags
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting curve 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setEndKnots(self, val='True', **kwargs):
        """
        End conditions for the curve 0 - uniform end knots, 1 - multiple end knots, Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setFitRebuild(self, val='True', **kwargs):
        """
        If true use the least squares fit rebuild. Otherwise use the convert method. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setKeepControlPoints(self, val='True', **kwargs):
        """
        If true, the CVs will remain the same. This forces uniform parameterization unless rebuildType is matchKnots. Default:false                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setKeepEndPoints(self, val='True', **kwargs):
        """
        If true, keep the endpoints the same. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setKeepRange(self, val='True', **kwargs):
        """
        Determine the parameterization for the resulting curve. 0 - reparameterize the resulting curve from 0 to 1, 1 - keep the original curve parameterization, 2 - reparameterize the result from 0 to number of spans Default:1                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setKeepTangents(self, val='True', **kwargs):
        """
        If true, keep the end tangents the same. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setRebuildType(self, val='True', **kwargs):
        """
        How to rebuild the input curve. 0 - uniform, 1 - reduce spans, 2 - match knots, 3 - remove multiple knots, 4 - curvature 5 - rebuild ends 6 - clean Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setSmartSurfaceCurveRebuild(self, val='True', **kwargs):
        """
        If true, curve on surface is rebuild in 3D and 2D info is kept Default:false                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setSpans(self, val='True', **kwargs):
        """
        The number of spans in resulting curve Used only if rebuildType is uniform. Default:4                  
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to rebuild. Default:0.01                  Common flags
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command rebuilds a curve by modifying its parameterization. In some cases
        the shape may also change. The rebuildType (-rt) determines how the curve is to
        be rebuilt. The optional second curve can be used to specify a reference
        parameterization.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting curve 1 - linear, 2 - quadratic, 3 - cubic, 5 -
            quintic, 7 - heptic Default:3
        
        - endKnots : end                 (int)           [create,query,edit]
            End conditions for the curve 0 - uniform end knots, 1 - multiple end knots,
            Default:0
        
        - fitRebuild : fr                (bool)          [create,query,edit]
            If true use the least squares fit rebuild. Otherwise use the convert method.
            Default:true
        
        - frozen : fzn                   (bool)          []
        
        - keepControlPoints : kcp        (bool)          [create,query,edit]
            If true, the CVs will remain the same. This forces uniform parameterization
            unless rebuildType is matchKnots. Default:false
        
        - keepEndPoints : kep            (bool)          [create,query,edit]
            If true, keep the endpoints the same. Default:true
        
        - keepRange : kr                 (int)           [create,query,edit]
            Determine the parameterization for the resulting curve. 0 - reparameterize the
            resulting curve from 0 to 1, 1 - keep the original curve parameterization, 2 -
            reparameterize the result from 0 to number of spans Default:1
        
        - keepTangents : kt              (bool)          [create,query,edit]
            If true, keep the end tangents the same. Default:true
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - noChanges : nc                 (bool)          []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.
        
        - rebuildType : rt               (int)           [create,query,edit]
            How to rebuild the input curve. 0 - uniform, 1 - reduce spans, 2 - match knots,
            3 - remove multiple knots, 4 - curvature 5 - rebuild ends 6 - clean Default:0
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - smartSurfaceCurveRebuild : scr (bool)          [create,query,edit]
            If true, curve on surface is rebuild in 3D and 2D info is kept Default:false
        
        - smooth : sm                    (float)         []
        
        - spans : s                      (int)           [create,query,edit]
            The number of spans in resulting curve Used only if rebuildType is uniform.
            Default:4
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to rebuild. Default:0.01                  Common flags
        
        
        Derived from mel command `maya.cmds.rebuildCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectNameFilter(ObjectFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class InsertKnotSurface(AbstractBaseCreate):
    def getAddKnots(self, **kwargs):
        """
        Whether to add knots or complement.  Complement means knots will be added to reach the specified number of knots. Default:true                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def getDirection(self, **kwargs):
        """
        Direction in which to insert knot: 0 - V direction, 1 - U direction Default:1                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def getInsertBetween(self, **kwargs):
        """
        If set to true, and there is more than one parameter value specified, the knots will get inserted at equally spaced intervals between the given parameter values, rather than at the parameter values themselves. Default:false                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def getNumberOfKnots(self, **kwargs):
        """
        How many knots to insert Default:1                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def getParameter(self, **kwargs):
        """
        Parameter value(s) where knots are added Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def setAddKnots(self, val='True', **kwargs):
        """
        Whether to add knots or complement.  Complement means knots will be added to reach the specified number of knots. Default:true                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        Direction in which to insert knot: 0 - V direction, 1 - U direction Default:1                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def setInsertBetween(self, val='True', **kwargs):
        """
        If set to true, and there is more than one parameter value specified, the knots will get inserted at equally spaced intervals between the given parameter values, rather than at the parameter values themselves. Default:false                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def setNumberOfKnots(self, val='True', **kwargs):
        """
        How many knots to insert Default:1                  
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        Parameter value(s) where knots are added Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The insertKnotSurface command inserts knots (aka isoparms) into a surface given
        a list of parameter values.  The number of knots to add at each parameter value
        and whether the knots are added or complemented can be specified. The name of
        the surface is returned and if history is on, the name of the resulting
        dependency node is also returned. You must specify one, none or all number of
        knots with the -nkflag. eg. if you specify none, then the default (one) knot
        will be added at each specified parameter value.  If you specify one -nkvalue
        then that number of knots will be added at each parameter value. Otherwise, you
        must specify the same number of -nkflags as -pflags, defining the number of
        knots to be added at each specified parameter value. You can insert up to
        degreeknots at a parameter value that isn't already an isoparm.  eg. for a
        degree 3 surface, you can insert up to 3 knots. Use this operation if you need
        more CVs in a local area of the surface. Use this operation if you want to
        create a corner in the surface. Note: A single insertKnotSurface command cannot
        insert in both directions at once; you must use two separate commands to do
        this.
        
        Flags:
        - addKnots : add                 (bool)          [create,query,edit]
            Whether to add knots or complement.  Complement means knots will be added to
            reach the specified number of knots. Default:true
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - direction : d                  (int)           [create,query,edit]
            Direction in which to insert knot: 0 - V direction, 1 - U direction Default:1
        
        - frozen : fzn                   (bool)          []
        
        - insertBetween : ib             (bool)          [create,query,edit]
            If set to true, and there is more than one parameter value specified, the knots
            will get inserted at equally spaced intervals between the given parameter
            values, rather than at the parameter values themselves. Default:false
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - numberOfKnots : nk             (int)           [create,query,edit]
            How many knots to insert Default:1
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            Parameter value(s) where knots are added Default:0.0                  Common
            flags
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.insertKnotSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSign(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AvgCurves(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class InverseMatrix(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveI16(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCellNoise(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKState2SK(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BossBlender(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLength(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CustomRigDefaultMappingNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiHair(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAOV(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyModifier(PolyBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKControlSetNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSetParameter(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUtility(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveF(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveRange(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectBinFilter(ObjectFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromMeshCoM(CurveFromMesh):
    __melnode__ = []
    
    
    __readonly__ = {}


class TransformGeometry(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAbs(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmSeExpr(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKEffector2State(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveNormalizerAngle(CurveNormalizer):
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdModifier(SubdBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSkin(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLog(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCollection(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SamplerInfo(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiExp(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_InitialState(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiFacingRatio(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiRoundCorners(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmMakeGuide(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CustomRigRetargeterNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BifrostLiquidMaterial(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OceanShader(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiGobo(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FitBspline(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.fitBspline`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.fitBspline`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        Tolerance for the fit.  The resulting curve will be kept within tolerance of the given points. Default:0.1                  Common flags
        
        
        Derived from mel command `maya.cmds.fitBspline`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.fitBspline`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.fitBspline`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        Tolerance for the fit.  The resulting curve will be kept within tolerance of the given points. Default:0.1                  Common flags
        
        
        Derived from mel command `maya.cmds.fitBspline`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The fitBspline command fits the CVs from an input curve and and returns a 3D
        curve.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - keepRange : kr                 (int)           []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - tolerance : tol                (float)         [create,query,edit]
            Tolerance for the fit.  The resulting curve will be kept within tolerance of the
            given points. Default:0.1                  Common flags
        
        
        Derived from mel command `maya.cmds.fitBspline`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BlendWeighted(Blend):
    __melnode__ = []
    
    
    __readonly__ = {}


class RbfSrf(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AttachSurface(AbstractBaseCreate):
    def getBlendBias(self, **kwargs):
        """
        Skew the result toward the first or the second curve depending on the blend factory being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getBlendKnotInsertion(self, **kwargs):
        """
        If set to true, insert a knot in one of the original curves (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getDirectionU(self, **kwargs):
        """
        If true attach in U direction of surface and V direction otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getKeepMultipleKnots(self, **kwargs):
        """
        If true, keep multiple knots at the join parameter. Otherwise remove them. Default:true                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getMethod(self, **kwargs):
        """
        Attach method (connect-0, blend-1) Default:0                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getParameter(self, **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getReverse1(self, **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the first input surface before doing attach. Otherwise, do nothing to the first input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getReverse2(self, **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the second input surface before doing attach. Otherwise, do nothing to the second input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getSwap1(self, **kwargs):
        """
        If true, swap the UV directions of the first input surface before doing attach. Otherwise, do nothing to the first input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getSwap2(self, **kwargs):
        """
        If true, swap the UV directions of the second input surface before doing attach. Otherwise, do nothing to the second input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def getTwist(self, **kwargs):
        """
        If true, reverse the second surface in the opposite direction (specified by directionU) before doing attach. This will avoid twists in the attached surfaces. Otherwise, do nothing to the second input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setBlendBias(self, val='True', **kwargs):
        """
        Skew the result toward the first or the second curve depending on the blend factory being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setBlendKnotInsertion(self, val='True', **kwargs):
        """
        If set to true, insert a knot in one of the original curves (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setDirectionU(self, val='True', **kwargs):
        """
        If true attach in U direction of surface and V direction otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setKeepMultipleKnots(self, val='True', **kwargs):
        """
        If true, keep multiple knots at the join parameter. Otherwise remove them. Default:true                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setMethod(self, val='True', **kwargs):
        """
        Attach method (connect-0, blend-1) Default:0                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setReverse1(self, val='True', **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the first input surface before doing attach. Otherwise, do nothing to the first input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setReverse2(self, val='True', **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the second input surface before doing attach. Otherwise, do nothing to the second input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setSwap1(self, val='True', **kwargs):
        """
        If true, swap the UV directions of the first input surface before doing attach. Otherwise, do nothing to the first input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setSwap2(self, val='True', **kwargs):
        """
        If true, swap the UV directions of the second input surface before doing attach. Otherwise, do nothing to the second input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    def setTwist(self, val='True', **kwargs):
        """
        If true, reverse the second surface in the opposite direction (specified by directionU) before doing attach. This will avoid twists in the attached surfaces. Otherwise, do nothing to the second input surface before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This attach command is used to attach surfaces. Once the surfaces are attached,
        there will be multiple knots at the joined point(s). These can be kept or
        removed if the user wishes. The end of the first surface is attached to the
        start of the second surface in the specified direction. Note: if the command is
        done with Keep Original off there will be an extra surface in the model (the
        second surface). The command does not delete it. The first surface is replaced
        by the attached surface.
        
        Flags:
        - blendBias : bb                 (float)         [create,query,edit]
            Skew the result toward the first or the second curve depending on the blend
            factory being smaller or larger than 0.5. Default:0.5
        
        - blendKnotInsertion : bki       (bool)          [create,query,edit]
            If set to true, insert a knot in one of the original curves (relative position
            given by the parameter attribute below) in order to produce a slightly different
            effect. Default:false
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - directionU : du                (bool)          [create,query,edit]
            If true attach in U direction of surface and V direction otherwise. Default:true
        
        - frozen : fzn                   (bool)          []
        
        - keepMultipleKnots : kmk        (bool)          [create,query,edit]
            If true, keep multiple knots at the join parameter. Otherwise remove them.
            Default:true
        
        - method : m                     (int)           [create,query,edit]
            Attach method (connect-0, blend-1) Default:0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            The parameter value for the positioning of the newly inserted knot. Default:0.1
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - reverse1 : rv1                 (bool)          [create,query,edit]
            If true, reverse the direction (specified by directionU) of the first input
            surface before doing attach. Otherwise, do nothing to the first input surface
            before attaching. NOTE: setting this attribute to random values will cause
            unpredictable results and is not supported. Default:false
        
        - reverse2 : rv2                 (bool)          [create,query,edit]
            If true, reverse the direction (specified by directionU) of the second input
            surface before doing attach. Otherwise, do nothing to the second input surface
            before attaching. NOTE: setting this attribute to random values will cause
            unpredictable results and is not supported. Default:false
        
        - swap1 : sw1                    (bool)          [create,query,edit]
            If true, swap the UV directions of the first input surface before doing attach.
            Otherwise, do nothing to the first input surface before attaching. NOTE: setting
            this attribute to random values will cause unpredictable results and is not
            supported. Default:false
        
        - swap2 : sw2                    (bool)          [create,query,edit]
            If true, swap the UV directions of the second input surface before doing attach.
            Otherwise, do nothing to the second input surface before attaching. NOTE:
            setting this attribute to random values will cause unpredictable results and is
            not supported. Default:false
        
        - twist : tw                     (bool)          [create,query,edit]
            If true, reverse the second surface in the opposite direction (specified by
            directionU) before doing attach. This will avoid twists in the attached
            surfaces. Otherwise, do nothing to the second input surface before attaching.
            NOTE: setting this attribute to random values will cause unpredictable results
            and is not supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.attachSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiFlat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiPassthrough(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TextureEnv(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKCharacterNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ReverseCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.reverseCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.reverseCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.reverseCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.reverseCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The reverseCurve command reverses the direction of a curve or curve-on-surface.
        A string is returned containing the pathname of the newly reversed curve and the
        name of the resulting dependency node.  The reversed curve has the same
        parameter range as the original curve.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curveOnSurface : cos           (bool)          [create]
            If possible, create 2D curve as a result.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - noChanges : nc                 (bool)          []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.reverseCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiVolumeCollector(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Channels(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiNormalize(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUvTransform(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MultiplyDivide(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiFloatToRgba(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKEffectorFromCharacter(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PlusMinusAverage(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class Untrim(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    def getNoChanges(self, **kwargs):
        """
        If set then the operation node will be automatically put into pass-through mode.                  
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    def getUntrimAll(self, **kwargs):
        """
        if true, untrim all the trims for the surface else untrim only the last trim                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    def setNoChanges(self, val='True', **kwargs):
        """
        If set then the operation node will be automatically put into pass-through mode.                  
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    def setUntrimAll(self, val='True', **kwargs):
        """
        if true, untrim all the trims for the surface else untrim only the last trim                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Untrim the surface.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curveOnSurface : cos           (bool)          [create]
            If possible, create 2D curve as a result.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - noChanges : nc                 (bool)          [create,query,edit]
            If set then the operation node will be automatically put into pass-through mode.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).
        
        - untrimAll : all                (bool)          [query,edit]
            if true, untrim all the trims for the surface else untrim only the last trim
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.untrim`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSubtract(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatToEuler(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyProjectCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def getDirection(self, **kwargs):
        """
        Direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        X direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        Y direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        Z direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        Tolerance to fit to.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        Direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        X direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        Y direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        Z direction of projection.                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        Tolerance to fit to.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The polyProjectCurve command creates curves by projecting a selected curve onto
        a selected poly mesh.  The direction of projection will be the current view
        direction unless the direction vector is specified with the -direction/-d flag.
        
        Flags:
        - addUnderTransform : aut        (bool)          [create]
            True if the resulting curve should be added under the source transform
        
        - automatic : automatic          (bool)          []
        
        - baryCoord : bc                 (float, float, float) []
        
        - baryCoord1 : bc1               (float)         []
        
        - baryCoord2 : bc2               (float)         []
        
        - baryCoord3 : bc3               (float)         []
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          []
        
        - curveSamples : cs              (int)           []
        
        - direction : d                  (float, float, float) [create,query,edit]
            Direction of projection.
        
        - directionX : dx                (float)         [create,query,edit]
            X direction of projection.
        
        - directionY : dy                (float)         [create,query,edit]
            Y direction of projection.
        
        - directionZ : dz                (float)         [create,query,edit]
            Z direction of projection.
        
        - face : f                       (int)           []
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          []
        
        - pointsOnEdges : poe            (bool)          []
        
        - tolerance : tol                (float)         [create,query,edit]
            Tolerance to fit to.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        - triangle : t                   (int)           []
        
        
        Derived from mel command `maya.cmds.polyProjectCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ComputeLocal(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKSkeletonGeneratorNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiDot(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorLogic(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectTypeFilter(ObjectFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class Container(ContainerBase):
    def addNode(self, val='True', **kwargs):
        """
        Specifies the list of nodes to add to container.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def clear(self):
        """
        Delete all members of the container.
        Derived from api method `maya.OpenMaya.MFnContainerNode.clear`
        """
        pass
    def force(self, val='True', **kwargs):
        """
        This flag can be used in conjunction with -addNode and -removeNode flags only. If specified with -addNode, nodes will be disconnected from their current containers before they are added to new one. If specified with -removeNode, nodes will be removed from all containers, instead of remaining in the parent container if being removed from a nested container.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getAsset(self, **kwargs):
        """
        When queried, if all the nodes in nodeList belong to the same container, returns container's name. Otherwise returns empty string. This flag is functionally equivalent to the findContainer flag.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getAssetMember(self, **kwargs):
        """
        Can be used during query in conjunction with the bindAttr flag to query for the only published attributes related to the specified node within the container.       
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getBindAttr(self, **kwargs):
        """
        Bind a contained attribute to an unbound published name on the interface of the container; returns a list of bound published names. The first string specifies the node and attribute name to be bound in node.attrformat. The second string specifies the name of the unbound published name. In query mode, returns a string array of the published names and their corresponding attributes. The flag can also be used in query mode in conjunction with the -publishName, -publishAsParent, and -publishAsChild flags.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getConnectionList(self, **kwargs):
        """
        Returns a list of the exterior connections to the container node.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getFileName(self, **kwargs):
        """
        Used to query for the assets associated with a given file name.       
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getFindContainer(self, **kwargs):
        """
        When queried, if all the nodes in nodeList belong to the same container, returns container's name. Otherwise returns empty string.       
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getIsContainer(self, **kwargs):
        """
        Return true if the selected or specified node is a container node. If multiple containers are queried, only the state of the first will be returned.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getMembers(self):
        """
        Return an array of the nodes included in this container.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getMembers`
        """
        pass
    def getNodeList(self, **kwargs):
        """
        When queried, returns a list of nodes in container. The list will be sorted in the order they were added to the container. This will also display any reordering done with the reorderContainer command.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getParentContainer(self):
        """
        Return the parent container, if there is one. Otherwise return an empty MObject
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getParentContainer`
        """
        pass
    def getPublishAsChild(self, **kwargs):
        """
        Publish contained node to the interface of the container to indicate it can be a child of external nodes. The second string is the name of the published node. In query mode, returns a string of the published names and the corresponding nodes. If -publishName flag is used in query mode, only returns the published names; if -bindAttr flag is used in query mode, only returns the name of the published nodes.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getPublishAsParent(self, **kwargs):
        """
        Publish contained node to the interface of the container to indicate it can be a parent to external nodes. The second string is the name of the published node. In query mode, returns a string of array of the published names and the corresponding nodes. If -publishName flag is used in query mode, only returns the published names; if -bindAttr flag is used in query mode, only returns the name of the published nodes.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getPublishAsRoot(self, **kwargs):
        """
        Publish or unpublish a node as a root. The significance of root transform node is twofold. When container-centric selection is enabled, the root transform will be selected if a container node in the hierarchy below it is selected in the main scene view. Also, when exporting a container proxy, any published root transformation attributes such as translate, rotate or scale will be hooked up to attributes on a stand-in node. In query mode, returns the node that has been published as root.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getPublishAttr(self, **kwargs):
        """
        In query mode, can only be used with the -publishName(-pn) flag, and takes an attribute as an argument; returns the published name of the attribute, if any.       
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getPublishName(self, **kwargs):
        """
        Publish a name to the interface of the container, and returns the actual name published to the interface.  In query mode, returns the published names for the container. If the -bindAttr flag is specified, returns only the names that are bound; if the -unbindAttr flag is specified, returns only the names that are not bound; if the -publishAsParent/-publishAsChild flags are specified, returns only names of published parents/children. if the -publishAttr is specified with an attribute argument in the node.attrformat, returns the published name for that attribute, if any.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getPublishedNames(self, unboundOnly):
        """
        Return a list of published names on the container. Depending on the arguments, either all published names or only unbound published names will be returned.
        
        Parameters:
        unboundOnly : 'bool'
            if true, only return names that are not associated with a plug
        
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getPublishedNames`
        """
        pass
    def getPublishedNodes(self, type):
        """
        Return a list of the published nodes of a given type. For any names that have assigned nodes, return the node at the corresponding array index. For any names that do not have assigned nodes, a NULL MObject will be at the corresponding array index.
        
        Parameters:
        type : 'Container.MPublishNodeType'
            published node type of interest
        
            values: 'parentAnchor', 'childAnchor', 'generic'
        
        
        Returns:
        Tuple[List['list'], List['PyNode']]
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getPublishedNodes`
        """
        pass
    def getPublishedPlugs(self):
        """
        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.
        
        Returns:
        Tuple[List['PyNode'], List['list']]
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getPublishedPlugs`
        """
        pass
    def getRootTransform(self):
        """
        Return the root transform, if there is one. Otherwise return an empty MObject.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getRootTransform`
        """
        pass
    def getSubcontainers(self):
        """
        Return an array of the container nodes included in this container.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getSubcontainers`
        """
        pass
    def getType(self, **kwargs):
        """
        By default, a container node will be created. Alternatively, the type flag can be used to indicate that a different type of container should be created. At the present time, the only other valid type of container node is dagContainer.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getUnbindAttr(self, **kwargs):
        """
        Unbind a published attribute from its published name on the interface of the container, leaving an unbound published name on the interface of the container; returns a list of unbound published names. The first string specifies the node and attribute name to be unbound in node.attrformat, and the second string specifies the name of the bound published name. In query mode, can only be used with the -publishName, -publishAsParent and -publishAsChild flags.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def getUnsortedOrder(self, **kwargs):
        """
        This flag has no effect on the operation of the container command (OBSOLETE).                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def includeHierarchyAbove(self, val='True', **kwargs):
        """
        Used to specify that the parent hierarchy of the supplied node list should also be included in the container (or deleted from the container). Hierarchy inclusion will stop at nodes which are members of other containers.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def includeHierarchyBelow(self, val='True', **kwargs):
        """
        Used to specify that the hierarchy below the supplied node list should also be included in the container (or delete from the container). Hierarchy inclusion will stop at nodes which are members of other containers.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def includeNetwork(self, val='True', **kwargs):
        """
        Used to specify that the node network connected to supplied node list should also be included in the container. Network traversal will stop at default nodes and nodes which are members of other containers.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def includeNetworkDetails(self, val='True', **kwargs):
        """
        Used to specify specific parts of the network that should be included. Valid arguments to this flag are: channels, sdk, constraints, historyand expressions, inputs, outputs. The difference between this flag and the includeNetwork flag, is that it will include all connected nodes regardless of their type. Note that dag containers include their children, so they will always include constraint nodes that are parented beneath the selected objects, even when constraints are not specified as an input.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def includeShaders(self, val='True', **kwargs):
        """
        Used to specify that for any shapes included, their shaders will also be included in the container.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def includeShapes(self, val='True', **kwargs):
        """
        Used to specify that for any transforms selected, their direct child shapes will be included in the container (or deleted from the container). This flag is not necessary when includeHierarchyBelow is used since the child shapes and all other descendents will automatically be included.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def includeTransform(self, val='True', **kwargs):
        """
        Used to specify that for any shapes selected, their parent transform will be included in the container (or deleted from the container). This flag is not necessary when includeHierarchyAbove is used since the parent transform and all of its parents will automatically be included.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def isCurrent(self):
        """
        Return whether the container node managed by this function set is the current container
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.isCurrent`
        """
        pass
    def makeCurrent(self, isCurrent='True'):
        """
        Set or clear whether the container managed by this function set is denoted as the the current container. If the flag is true and the container is allowed to be current, then the current container is set to be the container. Otherwise, if the container managed by the function set is the current container, then the current container is cleared.
        
        Parameters:
        isCurrent : 'bool'
            Specifies whether this container shall be current
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.makeCurrent`
        """
        pass
    def nodeNamePrefix(self, val='True', **kwargs):
        """
        Specifies that the name of published attributes should be of the form node_attr. Must be used with the -publishConnections/-pc flag.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def publishAndBind(self, val='True', **kwargs):
        """
        Publish the given name and bind the attribute to the given name. First string specifies the node and attribute name in node.attrformat. Second string specifies the name it should be published with.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def publishConnections(self, val='True', **kwargs):
        """
        Publish all connections from nodes inside the container to nodes outside the container.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def removeContainer(self, val='True', **kwargs):
        """
        Disconnects all the nodes from container and deletes container node.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def removeNode(self, val='True', **kwargs):
        """
        Specifies the list of nodes to remove from container. If node is a member of a nested container, it will be added to the parent container. To remove from all containers completely, use the -force flag.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def setBindAttr(self, val='True', **kwargs):
        """
        Bind a contained attribute to an unbound published name on the interface of the container; returns a list of bound published names. The first string specifies the node and attribute name to be bound in node.attrformat. The second string specifies the name of the unbound published name. In query mode, returns a string array of the published names and their corresponding attributes. The flag can also be used in query mode in conjunction with the -publishName, -publishAsParent, and -publishAsChild flags.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def setCurrent(self, val='True', **kwargs):
        """
        In create mode, specify that the newly created asset should be current. In edit mode, set the selected asset as current. In query, return the current asset.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def setPublishAsChild(self, val='True', **kwargs):
        """
        Publish contained node to the interface of the container to indicate it can be a child of external nodes. The second string is the name of the published node. In query mode, returns a string of the published names and the corresponding nodes. If -publishName flag is used in query mode, only returns the published names; if -bindAttr flag is used in query mode, only returns the name of the published nodes.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def setPublishAsParent(self, val='True', **kwargs):
        """
        Publish contained node to the interface of the container to indicate it can be a parent to external nodes. The second string is the name of the published node. In query mode, returns a string of array of the published names and the corresponding nodes. If -publishName flag is used in query mode, only returns the published names; if -bindAttr flag is used in query mode, only returns the name of the published nodes.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def setPublishAsRoot(self, val='True', **kwargs):
        """
        Publish or unpublish a node as a root. The significance of root transform node is twofold. When container-centric selection is enabled, the root transform will be selected if a container node in the hierarchy below it is selected in the main scene view. Also, when exporting a container proxy, any published root transformation attributes such as translate, rotate or scale will be hooked up to attributes on a stand-in node. In query mode, returns the node that has been published as root.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def setPublishName(self, val='True', **kwargs):
        """
        Publish a name to the interface of the container, and returns the actual name published to the interface.  In query mode, returns the published names for the container. If the -bindAttr flag is specified, returns only the names that are bound; if the -unbindAttr flag is specified, returns only the names that are not bound; if the -publishAsParent/-publishAsChild flags are specified, returns only names of published parents/children. if the -publishAttr is specified with an attribute argument in the node.attrformat, returns the published name for that attribute, if any.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def setUnbindAttr(self, val='True', **kwargs):
        """
        Unbind a published attribute from its published name on the interface of the container, leaving an unbound published name on the interface of the container; returns a list of unbound published names. The first string specifies the node and attribute name to be unbound in node.attrformat, and the second string specifies the name of the bound published name. In query mode, can only be used with the -publishName, -publishAsParent and -publishAsChild flags.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def unbindAndUnpublish(self, val='True', **kwargs):
        """
        Unbind the given attribute (in node.attrformat) and unpublish its associated name. Unbinding a compound may trigger unbinds of its compound parents/children. So the advantage of using this one flag is that it will automatically unpublish the names associated with these automatic unbinds.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def unbindChild(self, val='True', **kwargs):
        """
        Unbind the node published as child, but do not remove its published name from the interface of the container.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def unbindParent(self, val='True', **kwargs):
        """
        Unbind the node published as parent, but do not remove its published name from the interface of the container.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def unpublishChild(self, val='True', **kwargs):
        """
        Unpublish node published as child from the interface of the container                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def unpublishName(self, val='True', **kwargs):
        """
        Unpublish an unbound name from the interface of the container.                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    def unpublishParent(self, val='True', **kwargs):
        """
        Unpublish node published as parent from the interface of the container                  
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    @classmethod
    def getCurrent(self):
        """
        Retrieve the current container node.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnContainerNode.getCurrentAsMObject`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command can be used to create and query container nodes. It is also used to
        perform operations on containers such as: add and remove nodes from the
        containerpublish attributes from nodes inside the containerreplace the
        connections and values from one container onto another oneremove a container
        without removing its member nodes
        
        Flags:
        - addNode : an                   (unicode)       [create,edit]
            Specifies the list of nodes to add to container.
        
        - asset : a                      (unicode)       [query]
            When queried, if all the nodes in nodeList belong to the same container, returns
            container's name. Otherwise returns empty string. This flag is functionally
            equivalent to the findContainer flag.
        
        - assetMember : am               (unicode)       [query]
            Can be used during query in conjunction with the bindAttr flag to query for the
            only published attributes related to the specified node within the container.
        
        - bindAttr : ba                  (unicode, unicode) [query,edit]
            Bind a contained attribute to an unbound published name on the interface of the
            container; returns a list of bound published names. The first string specifies
            the node and attribute name to be bound in node.attrformat. The second string
            specifies the name of the unbound published name. In query mode, returns a
            string array of the published names and their corresponding attributes. The flag
            can also be used in query mode in conjunction with the -publishName,
            -publishAsParent, and -publishAsChild flags.
        
        - connectionList : cl            (bool)          [query]
            Returns a list of the exterior connections to the container node.
        
        - current : c                    (bool)          [create,query,edit]
            In create mode, specify that the newly created asset should be current. In edit
            mode, set the selected asset as current. In query, return the current asset.
        
        - fileName : fn                  (unicode)       [query]
            Used to query for the assets associated with a given file name.
        
        - findContainer : fc             (unicode)       [query]
            When queried, if all the nodes in nodeList belong to the same container, returns
            container's name. Otherwise returns empty string.
        
        - force : f                      (bool)          [create,edit]
            This flag can be used in conjunction with -addNode and -removeNode flags only.
            If specified with -addNode, nodes will be disconnected from their current
            containers before they are added to new one. If specified with -removeNode,
            nodes will be removed from all containers, instead of remaining in the parent
            container if being removed from a nested container.
        
        - includeHierarchyAbove : iha    (bool)          [create,edit]
            Used to specify that the parent hierarchy of the supplied node list should also
            be included in the container (or deleted from the container). Hierarchy
            inclusion will stop at nodes which are members of other containers.
        
        - includeHierarchyBelow : ihb    (bool)          [create,edit]
            Used to specify that the hierarchy below the supplied node list should also be
            included in the container (or delete from the container). Hierarchy inclusion
            will stop at nodes which are members of other containers.
        
        - includeNetwork : inc           (bool)          [create,edit]
            Used to specify that the node network connected to supplied node list should
            also be included in the container. Network traversal will stop at default nodes
            and nodes which are members of other containers.
        
        - includeNetworkDetails : ind    (unicode)       [create,edit]
            Used to specify specific parts of the network that should be included. Valid
            arguments to this flag are: channels, sdk, constraints, historyand expressions,
            inputs, outputs. The difference between this flag and the includeNetwork flag,
            is that it will include all connected nodes regardless of their type. Note that
            dag containers include their children, so they will always include constraint
            nodes that are parented beneath the selected objects, even when constraints are
            not specified as an input.
        
        - includeShaders : isd           (bool)          [create,edit]
            Used to specify that for any shapes included, their shaders will also be
            included in the container.
        
        - includeShapes : ish            (bool)          [create,edit]
            Used to specify that for any transforms selected, their direct child shapes will
            be included in the container (or deleted from the container). This flag is not
            necessary when includeHierarchyBelow is used since the child shapes and all
            other descendents will automatically be included.
        
        - includeTransform : it          (bool)          [create,edit]
            Used to specify that for any shapes selected, their parent transform will be
            included in the container (or deleted from the container). This flag is not
            necessary when includeHierarchyAbove is used since the parent transform and all
            of its parents will automatically be included.
        
        - isContainer : isc              (bool)          [query]
            Return true if the selected or specified node is a container node. If multiple
            containers are queried, only the state of the first will be returned.
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created container.
        
        - nodeList : nl                  (bool)          [query]
            When queried, returns a list of nodes in container. The list will be sorted in
            the order they were added to the container. This will also display any
            reordering done with the reorderContainer command.
        
        - nodeNamePrefix : nnp           (bool)          [create,edit]
            Specifies that the name of published attributes should be of the form node_attr.
            Must be used with the -publishConnections/-pc flag.
        
        - parentContainer : par          (bool)          [query]
            Flag to query the parent container of a specified container.
        
        - preview : p                    (bool)          [create]
            This flag is valid in create mode only. It indicates that you do not want the
            container to be created, instead you want to preview its contents. When this
            flag is used, Maya will select the nodes that would be put in the container if
            you did create the container. For example you can see what would go into the
            container with -includeNetwork, then modify your selection as desired, and do a
            create container with the selected objects only.
        
        - publishAndBind : pb            (unicode, unicode) [edit]
            Publish the given name and bind the attribute to the given name. First string
            specifies the node and attribute name in node.attrformat. Second string
            specifies the name it should be published with.
        
        - publishAsChild : pac           (unicode, unicode) [query,edit]
            Publish contained node to the interface of the container to indicate it can be a
            child of external nodes. The second string is the name of the published node. In
            query mode, returns a string of the published names and the corresponding nodes.
            If -publishName flag is used in query mode, only returns the published names; if
            -bindAttr flag is used in query mode, only returns the name of the published
            nodes.
        
        - publishAsParent : pap          (unicode, unicode) [query,edit]
            Publish contained node to the interface of the container to indicate it can be a
            parent to external nodes. The second string is the name of the published node.
            In query mode, returns a string of array of the published names and the
            corresponding nodes. If -publishName flag is used in query mode, only returns
            the published names; if -bindAttr flag is used in query mode, only returns the
            name of the published nodes.
        
        - publishAsRoot : pro            (unicode, bool) [query,edit]
            Publish or unpublish a node as a root. The significance of root transform node
            is twofold. When container-centric selection is enabled, the root transform will
            be selected if a container node in the hierarchy below it is selected in the
            main scene view. Also, when exporting a container proxy, any published root
            transformation attributes such as translate, rotate or scale will be hooked up
            to attributes on a stand-in node. In query mode, returns the node that has been
            published as root.
        
        - publishAttr : pa               (unicode)       [query]
            In query mode, can only be used with the -publishName(-pn) flag, and takes an
            attribute as an argument; returns the published name of the attribute, if any.
        
        - publishConnections : pc        (bool)          [create,edit]
            Publish all connections from nodes inside the container to nodes outside the
            container.
        
        - publishName : pn               (unicode)       [query,edit]
            Publish a name to the interface of the container, and returns the actual name
            published to the interface.  In query mode, returns the published names for the
            container. If the -bindAttr flag is specified, returns only the names that are
            bound; if the -unbindAttr flag is specified, returns only the names that are not
            bound; if the -publishAsParent/-publishAsChild flags are specified, returns only
            names of published parents/children. if the -publishAttr is specified with an
            attribute argument in the node.attrformat, returns the published name for that
            attribute, if any.
        
        - removeContainer : rc           (bool)          [edit]
            Disconnects all the nodes from container and deletes container node.
        
        - removeNode : rn                (unicode)       [edit]
            Specifies the list of nodes to remove from container. If node is a member of a
            nested container, it will be added to the parent container. To remove from all
            containers completely, use the -force flag.
        
        - type : typ                     (unicode)       [create,query]
            By default, a container node will be created. Alternatively, the type flag can
            be used to indicate that a different type of container should be created. At the
            present time, the only other valid type of container node is dagContainer.
        
        - unbindAndUnpublish : ubp       (unicode)       [edit]
            Unbind the given attribute (in node.attrformat) and unpublish its associated
            name. Unbinding a compound may trigger unbinds of its compound parents/children.
            So the advantage of using this one flag is that it will automatically unpublish
            the names associated with these automatic unbinds.
        
        - unbindAttr : ua                (unicode, unicode) [query,edit]
            Unbind a published attribute from its published name on the interface of the
            container, leaving an unbound published name on the interface of the container;
            returns a list of unbound published names. The first string specifies the node
            and attribute name to be unbound in node.attrformat, and the second string
            specifies the name of the bound published name. In query mode, can only be used
            with the -publishName, -publishAsParent and -publishAsChild flags.
        
        - unbindChild : unc              (unicode)       [edit]
            Unbind the node published as child, but do not remove its published name from
            the interface of the container.
        
        - unbindParent : unp             (unicode)       [edit]
            Unbind the node published as parent, but do not remove its published name from
            the interface of the container.
        
        - unpublishChild : upc           (unicode)       [edit]
            Unpublish node published as child from the interface of the container
        
        - unpublishName : un             (unicode)       [edit]
            Unpublish an unbound name from the interface of the container.
        
        - unpublishParent : upp          (unicode)       [edit]
            Unpublish node published as parent from the interface of the container
        
        - unsortedOrder : uso            (bool)          [query]
            This flag has no effect on the operation of the container command (OBSOLETE).
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.container`
        """
        pass
    MPublishNodeType = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AttachCurve(AbstractBaseCreate):
    def getBlendBias(self, **kwargs):
        """
        Skew the result toward the first or the second curve depending on the blend factory being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getBlendKnotInsertion(self, **kwargs):
        """
        If set to true, insert a knot in one of the original curves (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getKeepMultipleKnots(self, **kwargs):
        """
        If true, keep multiple knots at the join parameter. Otherwise remove them. Default:true                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getMethod(self, **kwargs):
        """
        Attach method (connect-0, blend-1) Default:0                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getParameter(self, **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getReverse1(self, **kwargs):
        """
        If true, reverse the first input curve before doing attach. Otherwise, do nothing to the first input curve before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def getReverse2(self, **kwargs):
        """
        If true, reverse the second input curve before doing attach. Otherwise, do nothing to the second input curve before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setBlendBias(self, val='True', **kwargs):
        """
        Skew the result toward the first or the second curve depending on the blend factory being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setBlendKnotInsertion(self, val='True', **kwargs):
        """
        If set to true, insert a knot in one of the original curves (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setKeepMultipleKnots(self, val='True', **kwargs):
        """
        If true, keep multiple knots at the join parameter. Otherwise remove them. Default:true                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setMethod(self, val='True', **kwargs):
        """
        Attach method (connect-0, blend-1) Default:0                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setReverse1(self, val='True', **kwargs):
        """
        If true, reverse the first input curve before doing attach. Otherwise, do nothing to the first input curve before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    def setReverse2(self, val='True', **kwargs):
        """
        If true, reverse the second input curve before doing attach. Otherwise, do nothing to the second input curve before attaching. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This attach command is used to attach curves. Once the curves are attached,
        there will be multiple knots at the joined point(s). These can be kept or
        removed if the user wishes. If there are two curves, the end of the first curve
        is attached to the start of the second curve. If there are more than two curves,
        closest endpoints are joined. Note: if the command is done with Keep Original
        off, the first curve is replaced by the attached curve. All other curves will
        remain, the command does not delete them.
        
        Flags:
        - blendBias : bb                 (float)         [create,query,edit]
            Skew the result toward the first or the second curve depending on the blend
            factory being smaller or larger than 0.5. Default:0.5
        
        - blendKnotInsertion : bki       (bool)          [create,query,edit]
            If set to true, insert a knot in one of the original curves (relative position
            given by the parameter attribute below) in order to produce a slightly different
            effect. Default:false
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - keepMultipleKnots : kmk        (bool)          [create,query,edit]
            If true, keep multiple knots at the join parameter. Otherwise remove them.
            Default:true
        
        - method : m                     (int)           [create,query,edit]
            Attach method (connect-0, blend-1) Default:0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            The parameter value for the positioning of the newly inserted knot. Default:0.1
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - reverse1 : rv1                 (bool)          [create,query,edit]
            If true, reverse the first input curve before doing attach. Otherwise, do
            nothing to the first input curve before attaching. NOTE: setting this attribute
            to random values will cause unpredictable results and is not supported.
            Default:false
        
        - reverse2 : rv2                 (bool)          [create,query,edit]
            If true, reverse the second input curve before doing attach. Otherwise, do
            nothing to the second input curve before attaching. NOTE: setting this attribute
            to random values will cause unpredictable results and is not supported.
            Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.attachCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MaterialFacade(Facade):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMaterialx(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatToAxisAngle(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BezierCurveToNurbs(AbstractBaseCreate):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The bezierCurveToNurbs command attempts to convert an existing NURBS curve to a
        Bezier curve.
        
        
        Derived from mel command `maya.cmds.bezierCurveToNurbs`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CacheBlend(CacheBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMultiply(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendInOut(AnimBlend):
    __melnode__ = []
    
    
    __readonly__ = {}


class GameFbxExporter(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THmotionPath(MotionPath):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiTriplanar(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderSetup(THdependNode):
    """
    class counterpart of mel function `renderSetup`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - renderLayers : rl              (bool)          []
        
        
        Derived from mel command `maya.cmds.renderSetup`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BevelPlus(AbstractBaseCreate):
    def getBevelInside(self, **kwargs):
        """
        If true, ensure surface always remains within the original profile curve Default:false                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def getCapSides(self, **kwargs):
        """
        How to cap the bevel. 1 - no caps2 - cap at start only3 - cap at end only4 - cap at start and endDefault:4                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def getInnerStyle(self, **kwargs):
        """
        Similar to outerStyle, this style is applied to all but the first (outer) curve specified.                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def getJoinSurfaces(self, **kwargs):
        """
        Attach bevelled surfaces into one surface for each input curve. Default:true                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def getNormalsOutwards(self, **kwargs):
        """
        If enabled, the normals point outwards on the resulting NURBS or poly surface.                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def getNumberOfSides(self, **kwargs):
        """
        How to apply the bevel. 1 - no bevels2 - bevel at start only3 - bevel at end only4 - bevel at start and endDefault:4                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def getOuterStyle(self, **kwargs):
        """
        Choose a style to use for the bevel of the first (outer) curve.  There are 15 predefined styles (values 0 to 14 can be used to select them). For those experienced with MEL, you can, after the fact, specify a custom curve and use it for the style curve. See the documentation for styleCurve node to see what requirements a style curve must satisfy.                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def setBevelInside(self, val='True', **kwargs):
        """
        If true, ensure surface always remains within the original profile curve Default:false                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def setInnerStyle(self, val='True', **kwargs):
        """
        Similar to outerStyle, this style is applied to all but the first (outer) curve specified.                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def setJoinSurfaces(self, val='True', **kwargs):
        """
        Attach bevelled surfaces into one surface for each input curve. Default:true                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def setNormalsOutwards(self, val='True', **kwargs):
        """
        If enabled, the normals point outwards on the resulting NURBS or poly surface.                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def setNumberOfSides(self, val='True', **kwargs):
        """
        How to apply the bevel. 1 - no bevels2 - bevel at start only3 - bevel at end only4 - bevel at start and endDefault:4                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    def setOuterStyle(self, val='True', **kwargs):
        """
        Choose a style to use for the bevel of the first (outer) curve.  There are 15 predefined styles (values 0 to 14 can be used to select them). For those experienced with MEL, you can, after the fact, specify a custom curve and use it for the style curve. See the documentation for styleCurve node to see what requirements a style curve must satisfy.                  
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The bevelPlus command creates a new bevel surface for the specified curves using
        a given style curve. The first curve should be the outsidecurve, and the
        (optional) rest of them should be inside of the first one. For predictable
        results, the curves should be planar and all in the same plane.
        
        Flags:
        - bevelInside : bin              (bool)          [create,query,edit]
            If true, ensure surface always remains within the original profile curve
            Default:false
        
        - caching : cch                  (bool)          []
        
        - capSides : cap                 (int)           [create,query]
            How to cap the bevel. 1 - no caps2 - cap at start only3 - cap at end only4 - cap
            at start and endDefault:4
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - depth : d                      (float)         []
        
        - extrudeDepth : ed              (float)         []
        
        - frozen : fzn                   (bool)          []
        
        - innerStyle : innerStyle        (int)           [create,query,edit]
            Similar to outerStyle, this style is applied to all but the first (outer) curve
            specified.
        
        - joinSurfaces : js              (bool)          [create,query,edit]
            Attach bevelled surfaces into one surface for each input curve. Default:true
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           []
        
        - normalsOutwards : no           (bool)          [create,query,edit]
            If enabled, the normals point outwards on the resulting NURBS or poly surface.
        
        - numberOfSides : ns             (int)           [create,query,edit]
            How to apply the bevel. 1 - no bevels2 - bevel at start only3 - bevel at end
            only4 - bevel at start and endDefault:4
        
        - outerStyle : os                (int)           [create,query,edit]
            Choose a style to use for the bevel of the first (outer) curve.  There are 15
            predefined styles (values 0 to 14 can be used to select them). For those
            experienced with MEL, you can, after the fact, specify a custom curve and use it
            for the style curve. See the documentation for styleCurve node to see what
            requirements a style curve must satisfy.
        
        - polyOutChordHeight : cht       (float)         []
        
        - polyOutChordHeightRatio : chr  (float)         []
        
        - polyOutCount : poc             (int)           []
        
        - polyOutCurveSamples : pcs      (int)           []
        
        - polyOutCurveType : pct         (int)           []
        
        - polyOutExtrusionSamples : pes  (int)           []
        
        - polyOutExtrusionType : pet     (int)           []
        
        - polyOutMethod : pom            (int)           []
        
        - polyOutUseChordHeight : uch    (bool)          []
        
        - polyOutUseChordHeightRatio : ucr (bool)          []
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - tolerance : tol                (float)         []
        
        - width : w                      (float)         []
        
        
        Derived from mel command `maya.cmds.bevelPlus`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class VectorProduct(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class Texture3d(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class SmoothCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.smoothCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.smoothCurve`
        """
        pass
    def getSmoothness(self, **kwargs):
        """
        smoothness factor Default:10.0                  Common flags
        
        
        Derived from mel command `maya.cmds.smoothCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.smoothCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.smoothCurve`
        """
        pass
    def setSmoothness(self, val='True', **kwargs):
        """
        smoothness factor Default:10.0                  Common flags
        
        
        Derived from mel command `maya.cmds.smoothCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The smooth command smooths the curve at the given control points.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - smoothness : s                 (float)         [create,query,edit]
            smoothness factor Default:10.0                  Common flags
        
        
        Derived from mel command `maya.cmds.smoothCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiFog(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Bevel(AbstractBaseCreate):
    def getBevelShapeType(self, **kwargs):
        """
        Shape type: 1 - straight cut, 2 - curve out, 3 - curve in Default:1                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getCornerType(self, **kwargs):
        """
        Corner type: 1 - linear, 2 - circular Default:2                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getDepth(self, **kwargs):
        """
        The depth for bevel Default:0.5                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getExtrudeDepth(self, **kwargs):
        """
        The extrude depth for bevel Default:1.0                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getJoinSurfaces(self, **kwargs):
        """
        Attach bevelled surfaces into one surface for each input curve. Default:true                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getNumberOfSides(self, **kwargs):
        """
        How to apply the bevel. 1 - no bevels2 - bevel at start only3 - bevel at end only4 - bevel at start and endDefault:4                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance for bevel offsets Default:0.01                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width for bevel Default:0.5                  Common flags
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setBevelShapeType(self, val='True', **kwargs):
        """
        Shape type: 1 - straight cut, 2 - curve out, 3 - curve in Default:1                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setCornerType(self, val='True', **kwargs):
        """
        Corner type: 1 - linear, 2 - circular Default:2                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setDepth(self, val='True', **kwargs):
        """
        The depth for bevel Default:0.5                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setExtrudeDepth(self, val='True', **kwargs):
        """
        The extrude depth for bevel Default:1.0                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setJoinSurfaces(self, val='True', **kwargs):
        """
        Attach bevelled surfaces into one surface for each input curve. Default:true                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setNumberOfSides(self, val='True', **kwargs):
        """
        How to apply the bevel. 1 - no bevels2 - bevel at start only3 - bevel at end only4 - bevel at start and endDefault:4                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance for bevel offsets Default:0.01                  
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width for bevel Default:0.5                  Common flags
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The bevel command creates a new bevel surface for the specified curve. The curve
        can be any nurbs curves.
        
        Flags:
        - bevelShapeType : bst           (int)           [create,query,edit]
            Shape type: 1 - straight cut, 2 - curve out, 3 - curve in Default:1
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - cornerType : ct                (int)           [create,query,edit]
            Corner type: 1 - linear, 2 - circular Default:2
        
        - depth : d                      (float)         [create,query,edit]
            The depth for bevel Default:0.5
        
        - extrudeDepth : ed              (float)         [create,query,edit]
            The extrude depth for bevel Default:1.0
        
        - frozen : fzn                   (bool)          []
        
        - joinSurfaces : js              (bool)          [create,query,edit]
            Attach bevelled surfaces into one surface for each input curve. Default:true
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - numberOfSides : ns             (int)           [create,query,edit]
            How to apply the bevel. 1 - no bevels2 - bevel at start only3 - bevel at end
            only4 - bevel at start and endDefault:4
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance for bevel offsets Default:0.01
        
        - width : w                      (float)         [create,query,edit]
            The width for bevel Default:0.5                  Common flags
        
        
        Derived from mel command `maya.cmds.bevel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderPass(ImageSource):
    def customTokenString(self):
        """
        Returns a custom token string that can be passed to MCommonRenderSettingsData::getImageName() to generate a file name for the pass.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderPass.customTokenString`
        """
        pass
    def frameBufferChannels(self):
        """
        Returns the number of channels of the frame buffer associated with the render pass.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderPass.frameBufferChannels`
        """
        pass
    def passID(self):
        """
        Returns the passID string that uniquely identifies the renderpass definition associated with the pass
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderPass.passID`
        """
        pass
    def usesFiltering(self):
        """
        Returns true if frame buffer filtering is requested. This setting may be ignored in the cases of frame buffer types and frame buffer semantics that do not allow interpolation.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaRender.MFnRenderPass.usesFiltering`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdivToNurbs(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKState2FK(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorMath(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ExtendCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getDistance(self, **kwargs):
        """
        The distance to extend Used only for extendMethod is byDistance. Default:1                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getExtendMethod(self, **kwargs):
        """
        The method with which to extend: 0 - based on distance, 2 - to a 3D point Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getExtensionType(self, **kwargs):
        """
        The type of extension: 0 - linear, 1 - circular, 2 - extrapolate Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getInputPoint(self, **kwargs):
        """
        The point to extend to (optional)                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getJoin(self, **kwargs):
        """
        If true, join the extension to original curve Default:true                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getNoChanges(self, **kwargs):
        """
        If set then the operation node will be automatically put into pass-through mode.                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getPointX(self, **kwargs):
        """
        X of the point to extend to Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getPointY(self, **kwargs):
        """
        Y of the point to extend to Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getPointZ(self, **kwargs):
        """
        Z of the point to extend to Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getRemoveMultipleKnots(self, **kwargs):
        """
        If true remove multiple knots at join Used only if join is true. Default:false                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def getStart(self, **kwargs):
        """
        Which end of the curve to extend. 0 - end, 1 - start, 2 - both Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setDistance(self, val='True', **kwargs):
        """
        The distance to extend Used only for extendMethod is byDistance. Default:1                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setExtendMethod(self, val='True', **kwargs):
        """
        The method with which to extend: 0 - based on distance, 2 - to a 3D point Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setExtensionType(self, val='True', **kwargs):
        """
        The type of extension: 0 - linear, 1 - circular, 2 - extrapolate Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setInputPoint(self, val='True', **kwargs):
        """
        The point to extend to (optional)                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setJoin(self, val='True', **kwargs):
        """
        If true, join the extension to original curve Default:true                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setNoChanges(self, val='True', **kwargs):
        """
        If set then the operation node will be automatically put into pass-through mode.                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setPointX(self, val='True', **kwargs):
        """
        X of the point to extend to Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setPointY(self, val='True', **kwargs):
        """
        Y of the point to extend to Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setPointZ(self, val='True', **kwargs):
        """
        Z of the point to extend to Default:0                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setRemoveMultipleKnots(self, val='True', **kwargs):
        """
        If true remove multiple knots at join Used only if join is true. Default:false                  
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    def setStart(self, val='True', **kwargs):
        """
        Which end of the curve to extend. 0 - end, 1 - start, 2 - both Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command extends a curve or creates a new curve as an extension
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curveOnSurface : cos           (bool)          [create]
            If possible, create 2D curve as a result.
        
        - distance : d                   (float)         [create,query,edit]
            The distance to extend Used only for extendMethod is byDistance. Default:1
        
        - extendMethod : em              (int)           [create,query,edit]
            The method with which to extend: 0 - based on distance, 2 - to a 3D point
            Default:0
        
        - extensionType : et             (int)           [create,query,edit]
            The type of extension: 0 - linear, 1 - circular, 2 - extrapolate Default:0
        
        - frozen : fzn                   (bool)          []
        
        - inputPoint : ip                (float, float, float) [create,query,edit]
            The point to extend to (optional)
        
        - join : jn                      (bool)          [create,query,edit]
            If true, join the extension to original curve Default:true
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - noChanges : nc                 (bool)          [create,query,edit]
            If set then the operation node will be automatically put into pass-through mode.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - pointX : px                    (float)         [create,query,edit]
            X of the point to extend to Default:0
        
        - pointY : py                    (float)         [create,query,edit]
            Y of the point to extend to Default:0
        
        - pointZ : pz                    (float)         [create,query,edit]
            Z of the point to extend to Default:0
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.
        
        - removeMultipleKnots : rmk      (bool)          [create,query,edit]
            If true remove multiple knots at join Used only if join is true. Default:false
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - start : s                      (int)           [create,query,edit]
            Which end of the curve to extend. 0 - end, 1 - start, 2 - both Default:1
            Common flags
        
        
        Derived from mel command `maya.cmds.extendCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AvgSurfacePoints(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class CloseSurface(AbstractBaseCreate):
    def getBlendBias(self, **kwargs):
        """
        Skew the result toward the first or the second surface depending on the blend value being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def getBlendKnotInsertion(self, **kwargs):
        """
        If set to true, insert a knot in one of the original surfaces (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def getDirection(self, **kwargs):
        """
        The direction in which to close: 0 - U, 1 - V, 2 - Both U and V Default:0                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def getParameter(self, **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def getPreserveShape(self, **kwargs):
        """
        0 - without preserving the shape 1 - preserve shape 2 - blend Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def setBlendBias(self, val='True', **kwargs):
        """
        Skew the result toward the first or the second surface depending on the blend value being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def setBlendKnotInsertion(self, val='True', **kwargs):
        """
        If set to true, insert a knot in one of the original surfaces (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        The direction in which to close: 0 - U, 1 - V, 2 - Both U and V Default:0                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    def setPreserveShape(self, val='True', **kwargs):
        """
        0 - without preserving the shape 1 - preserve shape 2 - blend Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The closeSurface command closes a surface in the U, V, or both directions,
        making it periodic. The close direction is controlled by the direction flag. If
        a surface is not specified in the command, then the first selected surface will
        be used. The pathname to the newly closed surface and the name of the resulting
        dependency node are returned. This command also handles selected surface
        isoparms. For example, if an isoparm is specified, surface1.u[0.33], then the
        surface will be closed in V, regardless of the direction flag.
        
        Flags:
        - blendBias : bb                 (float)         [create,query,edit]
            Skew the result toward the first or the second surface depending on the blend
            value being smaller or larger than 0.5. Default:0.5
        
        - blendKnotInsertion : bki       (bool)          [create,query,edit]
            If set to true, insert a knot in one of the original surfaces (relative position
            given by the parameter attribute below) in order to produce a slightly different
            effect. Default:false
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - direction : d                  (int)           [create,query,edit]
            The direction in which to close: 0 - U, 1 - V, 2 - Both U and V Default:0
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            The parameter value for the positioning of the newly inserted knot. Default:0.1
        
        - preserveShape : ps             (int)           [create,query,edit]
            0 - without preserving the shape 1 - preserve shape 2 - blend Default:1
            Common flags
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.closeSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveDL(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class LayeredTexture(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class HairPhysicalShader(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class IkPASolver(IkSolver):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAmbientOcclusion(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKRetargeterNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveFL(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class ArubaTessellate(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class FloatCondition(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HierarchyTestNode2(HierarchyTestNode1):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiRange(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLayerRgba(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveInfo(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUserDataVec2(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiBlackbody(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyOverride(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ExtendSurface(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def getDistance(self, **kwargs):
        """
        The distance to extend (for by distance only) Default:1                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def getExtendDirection(self, **kwargs):
        """
        Which parametric direction of the surface to extend ( 0 - U, 1 - V, 2 - both ) Default:0                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def getExtendMethod(self, **kwargs):
        """
        The extend method (0 - distance) Default:0                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def getExtendSide(self, **kwargs):
        """
        Which end of the surface to extend ( 0 - end, 1 - start, 2 - both ) Default:1                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def getExtensionType(self, **kwargs):
        """
        The type of extension (0 - tangent, 2 - extrapolate) Default:0                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def getJoin(self, **kwargs):
        """
        Join extension to original Default:true                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setDistance(self, val='True', **kwargs):
        """
        The distance to extend (for by distance only) Default:1                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setExtendDirection(self, val='True', **kwargs):
        """
        Which parametric direction of the surface to extend ( 0 - U, 1 - V, 2 - both ) Default:0                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setExtendMethod(self, val='True', **kwargs):
        """
        The extend method (0 - distance) Default:0                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setExtendSide(self, val='True', **kwargs):
        """
        Which end of the surface to extend ( 0 - end, 1 - start, 2 - both ) Default:1                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setExtensionType(self, val='True', **kwargs):
        """
        The type of extension (0 - tangent, 2 - extrapolate) Default:0                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setJoin(self, val='True', **kwargs):
        """
        Join extension to original Default:true                  
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command extends a surface or creates a new surface as an extension.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - distance : d                   (float)         [create,query,edit]
            The distance to extend (for by distance only) Default:1
        
        - extendDirection : ed           (int)           [create,query,edit]
            Which parametric direction of the surface to extend ( 0 - U, 1 - V, 2 - both )
            Default:0
        
        - extendMethod : em              (int)           [create,query,edit]
            The extend method (0 - distance) Default:0
        
        - extendSide : es                (int)           [create,query,edit]
            Which end of the surface to extend ( 0 - end, 1 - start, 2 - both ) Default:1
        
        - extensionType : et             (int)           [create,query,edit]
            The type of extension (0 - tangent, 2 - extrapolate) Default:0
        
        - frozen : fzn                   (bool)          []
        
        - join : jn                      (bool)          [create,query,edit]
            Join extension to original Default:true
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - noChanges : nc                 (bool)          []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.extendSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AlignSurface(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getCurvatureContinuity(self, **kwargs):
        """
        Curvature continuity is on if true and off otherwise. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getCurvatureScale1(self, **kwargs):
        """
        Curvature scale applied to curvature of first surface for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getCurvatureScale2(self, **kwargs):
        """
        Curvature scale applied to curvature of second surface for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getDirectionU(self, **kwargs):
        """
        If true use U direction of surface and V direction otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getJoinParameter(self, **kwargs):
        """
        Parameter on reference surface where modified surface is to be aligned to. Default:123456.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getPositionalContinuity(self, **kwargs):
        """
        Positional continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getPositionalContinuityType(self, **kwargs):
        """
        Positional continuity type legal values: 1 - move first surface, 2 - move second surface, 3 - move both surfaces, 4 - modify first surface, 5 - modify second surface, 6 - modify both surfaces Default:1                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getReverse1(self, **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the first input surface before doing align. Otherwise, do nothing to the first input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getReverse2(self, **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the second input surface before doing align. Otherwise, do nothing to the second input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getSwap1(self, **kwargs):
        """
        If true, swap the UV directions of the first input surface before doing align. Otherwise, do nothing to the first input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getSwap2(self, **kwargs):
        """
        If true, swap the UV directions of the second input surface before doing align. Otherwise, do nothing to the second input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getTangentContinuity(self, **kwargs):
        """
        Tangent continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getTangentContinuityType(self, **kwargs):
        """
        Tangent continuity type legal values: 1 - do tangent continuity on first surface, 2 - do tangent continuity on second surface Default:1                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getTangentScale1(self, **kwargs):
        """
        Tangent scale applied to tangent of first surface for tangent continuity. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getTangentScale2(self, **kwargs):
        """
        Tangent scale applied to tangent of second surface for tangent continuity. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def getTwist(self, **kwargs):
        """
        If true, reverse the second surface in the opposite direction (specified by directionU) before doing align. This will avoid twists in the aligned surfaces. Otherwise, do nothing to the second input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setCurvatureContinuity(self, val='True', **kwargs):
        """
        Curvature continuity is on if true and off otherwise. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setCurvatureScale1(self, val='True', **kwargs):
        """
        Curvature scale applied to curvature of first surface for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setCurvatureScale2(self, val='True', **kwargs):
        """
        Curvature scale applied to curvature of second surface for curvature continuity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setDirectionU(self, val='True', **kwargs):
        """
        If true use U direction of surface and V direction otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setJoinParameter(self, val='True', **kwargs):
        """
        Parameter on reference surface where modified surface is to be aligned to. Default:123456.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setPositionalContinuity(self, val='True', **kwargs):
        """
        Positional continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setPositionalContinuityType(self, val='True', **kwargs):
        """
        Positional continuity type legal values: 1 - move first surface, 2 - move second surface, 3 - move both surfaces, 4 - modify first surface, 5 - modify second surface, 6 - modify both surfaces Default:1                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setReverse1(self, val='True', **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the first input surface before doing align. Otherwise, do nothing to the first input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setReverse2(self, val='True', **kwargs):
        """
        If true, reverse the direction (specified by directionU) of the second input surface before doing align. Otherwise, do nothing to the second input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setSwap1(self, val='True', **kwargs):
        """
        If true, swap the UV directions of the first input surface before doing align. Otherwise, do nothing to the first input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setSwap2(self, val='True', **kwargs):
        """
        If true, swap the UV directions of the second input surface before doing align. Otherwise, do nothing to the second input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setTangentContinuity(self, val='True', **kwargs):
        """
        Tangent continuity is on if true and off otherwise. Default:true                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setTangentContinuityType(self, val='True', **kwargs):
        """
        Tangent continuity type legal values: 1 - do tangent continuity on first surface, 2 - do tangent continuity on second surface Default:1                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setTangentScale1(self, val='True', **kwargs):
        """
        Tangent scale applied to tangent of first surface for tangent continuity. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setTangentScale2(self, val='True', **kwargs):
        """
        Tangent scale applied to tangent of second surface for tangent continuity. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    def setTwist(self, val='True', **kwargs):
        """
        If true, reverse the second surface in the opposite direction (specified by directionU) before doing align. This will avoid twists in the aligned surfaces. Otherwise, do nothing to the second input surface before aligning. NOTE: setting this attribute to random values will cause unpredictable results and is not supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The surface align command is used to align surfaces in maya. The main alignment
        options are positional, tangent and curvature continuity. Curvature continuity
        implies tangent continuity. NOTE: this tool is based on Studio's align tool.
        Positional continuity means the surfaces (move) or the ends of the surfaces
        (modify) are changed. Tangent continuity means one of the surfaces is modified
        to be tangent at the points where they meet. Curvature continuity means one of
        the surfaces is modified to be curvature continuous as well as tangent. The
        default behaviour, when no surfaces or flags are passed, is to only do
        positional and tangent continuity on the active list with the end of the first
        surface and the start of the other surface used for alignment.
        
        Flags:
        - attach : at                    (bool)          [create]
            Should surfaces be attached after alignment?
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curvatureContinuity : cc       (bool)          [create,query,edit]
            Curvature continuity is on if true and off otherwise. Default:false
        
        - curvatureScale1 : cs1          (float)         [create,query,edit]
            Curvature scale applied to curvature of first surface for curvature continuity.
            Default:0.0
        
        - curvatureScale2 : cs2          (float)         [create,query,edit]
            Curvature scale applied to curvature of second surface for curvature continuity.
            Default:0.0
        
        - directionU : du                (bool)          [create,query,edit]
            If true use U direction of surface and V direction otherwise. Default:true
        
        - frozen : fzn                   (bool)          []
        
        - joinParameter : jnp            (float)         [create,query,edit]
            Parameter on reference surface where modified surface is to be aligned to.
            Default:123456.0
        
        - keepMultipleKnots : kmk        (bool)          [create]
            Should multiple knots be kept?
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - positionalContinuity : pc      (bool)          [create,query,edit]
            Positional continuity is on if true and off otherwise. Default:true
        
        - positionalContinuityType : pct (int)           [create,query,edit]
            Positional continuity type legal values: 1 - move first surface, 2 - move second
            surface, 3 - move both surfaces, 4 - modify first surface, 5 - modify second
            surface, 6 - modify both surfaces Default:1
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - reverse1 : rv1                 (bool)          [create,query,edit]
            If true, reverse the direction (specified by directionU) of the first input
            surface before doing align. Otherwise, do nothing to the first input surface
            before aligning. NOTE: setting this attribute to random values will cause
            unpredictable results and is not supported. Default:false
        
        - reverse2 : rv2                 (bool)          [create,query,edit]
            If true, reverse the direction (specified by directionU) of the second input
            surface before doing align. Otherwise, do nothing to the second input surface
            before aligning. NOTE: setting this attribute to random values will cause
            unpredictable results and is not supported. Default:false
        
        - swap1 : sw1                    (bool)          [create,query,edit]
            If true, swap the UV directions of the first input surface before doing align.
            Otherwise, do nothing to the first input surface before aligning. NOTE: setting
            this attribute to random values will cause unpredictable results and is not
            supported. Default:false
        
        - swap2 : sw2                    (bool)          [create,query,edit]
            If true, swap the UV directions of the second input surface before doing align.
            Otherwise, do nothing to the second input surface before aligning. NOTE: setting
            this attribute to random values will cause unpredictable results and is not
            supported. Default:false
        
        - tangentContinuity : tc         (bool)          [create,query,edit]
            Tangent continuity is on if true and off otherwise. Default:true
        
        - tangentContinuityType : tct    (int)           [create,query,edit]
            Tangent continuity type legal values: 1 - do tangent continuity on first
            surface, 2 - do tangent continuity on second surface Default:1
        
        - tangentScale1 : ts1            (float)         [create,query,edit]
            Tangent scale applied to tangent of first surface for tangent continuity.
            Default:1.0
        
        - tangentScale2 : ts2            (float)         [create,query,edit]
            Tangent scale applied to tangent of second surface for tangent continuity.
            Default:1.0
        
        - twist : tw                     (bool)          [create,query,edit]
            If true, reverse the second surface in the opposite direction (specified by
            directionU) before doing align. This will avoid twists in the aligned surfaces.
            Otherwise, do nothing to the second input surface before aligning. NOTE: setting
            this attribute to random values will cause unpredictable results and is not
            supported. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.alignSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_MultiCurve(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatNormalize(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiPhysicalSky(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BifMeshImportNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DetachCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    def getKeep(self, **kwargs):
        """
        Whether or not to keep a detached piece.  This multi attribute should be one element larger than the parameter multi attribute. Default:true                  
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    def getParameter(self, **kwargs):
        """
        Parameter values to detach at Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    def setKeep(self, val='True', **kwargs):
        """
        Whether or not to keep a detached piece.  This multi attribute should be one element larger than the parameter multi attribute. Default:true                  
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        Parameter values to detach at Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The detachCurve command detaches a curve into pieces, given a list of parameter
        values.  You can also specify which pieces to keep and which to discard using
        the -kflag. The names of the newly detached curve(s) is returned.  If history is
        on, then the name of the resulting dependency node is also returned. You can use
        this command to open a periodic curve at a particular parameter value.  You
        would use this command with only one -pflag. If you are specifying -kflags, then
        you must specify one, none or all -kflags.  If you are specifying all -kflags,
        there must be one more -kflag than -pflags.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curveOnSurface : cos           (bool)          [create]
            If possible, create 2D curve as a result.
        
        - frozen : fzn                   (bool)          []
        
        - keep : k                       (bool)          [create,query,edit]
            Whether or not to keep a detached piece.  This multi attribute should be one
            element larger than the parameter multi attribute. Default:true
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            Parameter values to detach at Default:0.0                  Common flags
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.detachCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUserDataString(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderedImageSource(ImageSource):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveScale(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class Substance(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ComputeGlobal(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectScriptFilter(ObjectFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMin(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THgeometryFilter(GeometryFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class BlendShape(GeometryFilter):
    def addBaseObject(self, object):
        """
        Adds a new base object to the deformer. This object will be deformed as targets are added for it and the deformation parameters change.
        
        Parameters:
        object : 'PyNode'
            new base object
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.addBaseObject`
        """
        pass
    def addTarget(self, baseObject, weightIndex, newTarget, fullWeight, targetType="'object'"):
        """
        Adds a new target object for the given base object. The weight index says which of the deformer's weight values will control this target's affects on the base object. The full weight argument determines at what weight the target is in full effect. If a base object has no other targets and the weight is set to the 'full weight', then the base object will look just like the target object.
        
        Parameters:
        baseObject : 'PyNode'
            base object for the target
        weightIndex : 'int'
            weight index to use for target's effect
        newTarget : 'PyNode'
            new target object for the given base
        fullWeight : 'float'
            weight value at which the target is in full effect
        targetType : 'BlendShape.TargetType'
            target type for the target
        
            values: 'object', 'tangent'
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.addTarget`
        """
        pass
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def automatic(self, val='True', **kwargs):
        """
        The -automatic flag is used to specify deformer ordering in a way that choses between -frontOfChain and -before automatically. If the geometry being deformed is only affected by invertible deformers, the -frontOfChain mode is used, otherwise the -before mode is used.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def copyDelta(self, val='True', **kwargs):
        """
        Set the base, source, and destination delta index values.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def copyInBetweenDelta(self, val='True', **kwargs):
        """
        Set the base, target, source, and destination delta index values.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def export(self, val='True', **kwargs):
        """
        Export the shapes to the named file path.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def exportTarget(self, val='True', **kwargs):
        """
        Specify the base and target index pairs for the export.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def flipTarget(self, val='True', **kwargs):
        """
        Flip the list of base and target pairs.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getBaseObjects(self):
        """
        Get a list of all of the base objects for this deformer. The objects returned will be the deformed versions of the base objects.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.getBaseObjects`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getEnvelope(self):
        """
        Gets the envelope value of the deformer.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.envelope`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getNormalizationGroups(self, **kwargs):
        """
        Returns a list of the used normalization group IDs.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getOrigin(self):
        """
        Gets the origin space. It defines the point around which the differences in the geometry are calculated.
        
        Returns:
        'BlendShape.Origin'
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.origin`
        """
        pass
    def getSymmetryAxis(self, **kwargs):
        """
        Axis for symmetry. Valid values are X, Y, and Z.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getSymmetryEdge(self, **kwargs):
        """
        One or two symmetry edge names, separated by a .. See the blendShape node's symmetryEdge attribute for legal values.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getSymmetrySpace(self, **kwargs):
        """
        Space for symmetry. 0 = Topological, 1 = Object, 2 = UV                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getTarget(self, **kwargs):
        """
        Set target object as the index target shape for the base shape base object. The full influence of target shape takes effect when its shape weight is targetValue. Parameter list: string: the base objectint: indexstring: the target objectdouble: target value
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getTargets(self, baseObject, weightIndex):
        """
        Get a list of all of the target objects for the given base object that affect it based on the given weight index.
        
        Parameters:
        baseObject : 'PyNode'
            The base shape of interest.
        weightIndex : 'int'
            The index of the weight attribute. Since the weight indices may be sparse, the weightIndexList method should be used to find the weight indices used by a given blendShape.
        
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.getTargets`
        """
        pass
    def getTransform(self, **kwargs):
        """
        Set transform for target, then the deltas will become relative to a post transform. Typically the best workflow for this option is to choose a joint that is related to the fix you have introduced. This flag should be used only if the Deformation orderof blendShape node is Before.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def getWeight(self, index):
        """
        Get the weight value at the given index. To be valid, a weight value should only be requested at index values returned by MFnBlendShapeDeformer::weightIndexList.
        
        Parameters:
        index : 'int'
            index of weight value
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.weight`
        """
        pass
    def getWeightCount(self, **kwargs):
        """
        Set the number of shape weight values.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def historyLocation(self):
        """
        Gets the history location (deformation order). It defines where to place the deformer node in the chain.
        
        Returns:
        'BlendShape.HistoryLocation'
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.historyLocation`
        """
        pass
    def inBetween(self, val='True', **kwargs):
        """
        Indicate that the specified target should serve as an inbetween. An inbetween target is one that serves as an intermediate target between the base shape and another target.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def inBetweenIndex(self, val='True', **kwargs):
        """
        Only used with the -rtd/-resetTargetDelta flag to remove delta values for points in the inbetween target geometry defined by this index.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def inBetweenType(self, val='True', **kwargs):
        """
        Specify if the in-between target to be created is relative to the hero target or if it is absolute. If it is relative to hero targets, the in-between target will get any changes made to the hero target. Valid values are relativeand absolute. This flag should always be used with the -ib/-inBetween and -t/-target flags.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def ip(self, val='True', **kwargs):
        """
        Import the shapes from the named file path.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def mergeSource(self, val='True', **kwargs):
        """
        List of source indexes for a merge.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def mergeTarget(self, val='True', **kwargs):
        """
        Target index of a merge                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def mirrorDirection(self, val='True', **kwargs):
        """
        Mirror direction; 0 = negative, 1 = positive                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def mirrorTarget(self, val='True', **kwargs):
        """
        Mirror the list of base and target pairs.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def numWeights(self):
        """
        Return the number of weight values that this blend shape deformer has. The number of weight values is equal to the number of targets. Targets are either shapes in the dag or baked data on the blendShape node (when a target shape is deleted).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.numWeights`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def removeTarget(self, baseObject, weightIndex, target, fullWeight):
        """
        Remove a target object for the given base object. The weight index specifies the index at which target is connected. The full weight argument specifies at what weight the target is in full effect.
        
        Parameters:
        baseObject : 'PyNode'
            base object for the target
        weightIndex : 'int'
            weight index corresponding to the target
        target : 'PyNode'
            target object for the given base to be removed
        fullWeight : 'float'
            weight value at which the target is in full effect
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.removeTarget`
        """
        pass
    def resetTargetDelta(self, val='True', **kwargs):
        """
        Remove all delta values for points in the target geometry, including all sequential targets defined by target index. Parameter list: uint: the base object indexuint: the target index
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def setEnvelope(self, envelope):
        """
        Sets the envelope value of the deformer.
        
        Parameters:
        envelope : 'float'
            envelope value
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.setEnvelope`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def setOrigin(self, space):
        """
        Sets the origin space. It defines the point around which the differences in the geometry are calculated.
        
        Parameters:
        space : 'BlendShape.Origin'
            origin space
        
            values: 'localOrigin', 'worldOrigin'
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.setOrigin`
        """
        pass
    def setSymmetryAxis(self, val='True', **kwargs):
        """
        Axis for symmetry. Valid values are X, Y, and Z.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def setSymmetryEdge(self, val='True', **kwargs):
        """
        One or two symmetry edge names, separated by a .. See the blendShape node's symmetryEdge attribute for legal values.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def setSymmetrySpace(self, val='True', **kwargs):
        """
        Space for symmetry. 0 = Topological, 1 = Object, 2 = UV                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def setTarget(self, val='True', **kwargs):
        """
        Set target object as the index target shape for the base shape base object. The full influence of target shape takes effect when its shape weight is targetValue. Parameter list: string: the base objectint: indexstring: the target objectdouble: target value
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def setTransform(self, val='True', **kwargs):
        """
        Set transform for target, then the deltas will become relative to a post transform. Typically the best workflow for this option is to choose a joint that is related to the fix you have introduced. This flag should be used only if the Deformation orderof blendShape node is Before.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def setWeight(self, index, weight):
        """
        Set the weight value at the given index.
        
        Parameters:
        index : 'int'
            index of weight value
        weight : 'float'
            new weight value
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.setWeight`
        """
        pass
    def setWeightCount(self, val='True', **kwargs):
        """
        Set the number of shape weight values.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def suppressDialog(self, val='True', **kwargs):
        """
        Suppress dialog box and run the command as defined by the user.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def tangentSpace(self, val='True', **kwargs):
        """
        Indicate that the delta of the specified target should be relative to the tangent space of the surface.                  
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    def targetItemIndexList(self, weightIndex, baseObject):
        """
        A base object may have more than one target using the same element of the blendShape's 'weights' array. We refer to these as the base object's "target items" for that weight index.
        
        Parameters:
        weightIndex : 'int'
            'weights' array index.
        baseObject : 'PyNode'
            The deformed object of interest
        
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.targetItemIndexList`
        """
        pass
    def weightIndexList(self):
        """
        Return the array index numbers corresponding to the targets. The resulting index list will be the length of MFnBlendShape::numWeights. This method exists because the indices of the targets can be sparse. For example, if a target has been removed using Deform -> Edit BlendShape -> Remove.
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMayaAnim.MFnBlendShapeDeformer.weightIndexList`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a blendShape deformer, which blends in specified amounts of
        each target shape to the initial base shape. Each base shape is deformed by its
        own set of target shapes. Every target shape has an index that associates it
        with one of the shape weight values.In the create mode the first item on the
        selection list is treated as the base and the remaining inputs as targets. If
        the first item on the list has multiple shapes grouped beneath it, the targets
        must have an identical shape hierarchy. Additional base shapes can be added in
        edit mode using the deformers -g flag.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - automatic : at                 (bool)          [create,edit]
            The -automatic flag is used to specify deformer ordering in a way that choses
            between -frontOfChain and -before automatically. If the geometry being deformed
            is only affected by invertible deformers, the -frontOfChain mode is used,
            otherwise the -before mode is used.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - copyDelta : cd                 (int, int, int) [edit]
            Set the base, source, and destination delta index values.
        
        - copyInBetweenDelta : cid       (int, int, int, int) [edit]
            Set the base, target, source, and destination delta index values.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - envelope : en                  (float)         [create,query,edit]
            Set the envelope value for the deformer, controlling how much of the total
            deformation gets applied. Default is 1.0.
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - export : ep                    (unicode)       [edit]
            Export the shapes to the named file path.
        
        - exportTarget : et              (int, int)      [edit]
            Specify the base and target index pairs for the export.
        
        - flipTarget : ft                (int, int)      [edit]
            Flip the list of base and target pairs.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - inBetween : ib                 (bool)          [create,edit]
            Indicate that the specified target should serve as an inbetween. An inbetween
            target is one that serves as an intermediate target between the base shape and
            another target.
        
        - inBetweenIndex : ibi           (int)           [edit]
            Only used with the -rtd/-resetTargetDelta flag to remove delta values for points
            in the inbetween target geometry defined by this index.
        
        - inBetweenType : ibt            (unicode)       [create,edit]
            Specify if the in-between target to be created is relative to the hero target or
            if it is absolute. If it is relative to hero targets, the in-between target will
            get any changes made to the hero target. Valid values are relativeand absolute.
            This flag should always be used with the -ib/-inBetween and -t/-target flags.
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - ip : ip                        (unicode)       [edit]
            Import the shapes from the named file path.
        
        - mergeSource : mgs              (int)           [edit]
            List of source indexes for a merge.
        
        - mergeTarget : mgt              (int)           [edit]
            Target index of a merge
        
        - mirrorDirection : md           (int)           [edit]
            Mirror direction; 0 = negative, 1 = positive
        
        - mirrorTarget : mt              (int, int)      [edit]
            Mirror the list of base and target pairs.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - normalizationGroups : ng       (bool)          [query]
            Returns a list of the used normalization group IDs.
        
        - origin : o                     (unicode)       [create]
            blendShape will be performed with respect to the world by default. Valid values
            are worldand local. The local flag will cause the blend shape to be performed
            with respect to the shape's local origin.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - resetTargetDelta : rtd         (int, int)      [edit]
            Remove all delta values for points in the target geometry, including all
            sequential targets defined by target index. Parameter list: uint: the base
            object indexuint: the target index
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - suppressDialog : sd            (bool)          [create,edit]
            Suppress dialog box and run the command as defined by the user.
        
        - symmetryAxis : sa              (unicode)       [query,edit]
            Axis for symmetry. Valid values are X, Y, and Z.
        
        - symmetryEdge : se              (unicode)       [query,edit]
            One or two symmetry edge names, separated by a .. See the blendShape node's
            symmetryEdge attribute for legal values.
        
        - symmetrySpace : ss             (int)           [query,edit]
            Space for symmetry. 0 = Topological, 1 = Object, 2 = UV
        
        - tangentSpace : ts              (bool)          [create,edit]
            Indicate that the delta of the specified target should be relative to the
            tangent space of the surface.
        
        - target : t                     (unicode, int, unicode, float) [create,query,edit]
            Set target object as the index target shape for the base shape base object. The
            full influence of target shape takes effect when its shape weight is
            targetValue. Parameter list: string: the base objectint: indexstring: the target
            objectdouble: target value
        
        - topologyCheck : tc             (bool)          [create]
            Set the state of checking for a topology match between the shapes being blended.
            Default is on.
        
        - transform : tr                 (unicode)       [query,edit]
            Set transform for target, then the deltas will become relative to a post
            transform. Typically the best workflow for this option is to choose a joint that
            is related to the fix you have introduced. This flag should be used only if the
            Deformation orderof blendShape node is Before.
        
        - weight : w                     (int, float)    [create,query,edit]
            Set the weight value (second parameter) at index (first parameter).
        
        - weightCount : wc               (int)           [create,query,edit]
            Set the number of shape weight values.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.blendShape`
        """
        pass
    HistoryLocation = {}
    
    
    Origin = {}
    
    
    TargetType = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class StyleCurve(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveI32(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeBoolean(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiBump2d(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectRenderFilter(ObjectFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveTL(AnimCurve):
    def addKey(self, time, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        time : 'Time'
            Time at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AiVolumeSampleRgb(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class LayeredShader(ShadingDependNode):
    def getColor(self, lIndex='0'):
        """
        Retrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.
        
        Parameters:
        lIndex : 'int'
            Index of the shader's entry in the inputs attribute array element.
        
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.color`
        """
        pass
    def getCompositingFlag(self):
        """
        Retrieves the value of the "compositingFlag" attribute of a shader node.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.compositingFlag`
        """
        pass
    def getGlowColor(self, lIndex='0'):
        """
        Retrieves the value of the "glowColor" attribute of a shader node. This attribute represents the ambient color of the shader.
        
        Parameters:
        lIndex : 'int'
            Index of the shader's entry in the inputs attribute array element.
        
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.glowColor`
        """
        pass
    def getHardwareColor(self):
        """
        Retrieves the value of the "hardwareColor" attribute of a shader node. This attribute represents the color of the material that appears in shaded mode.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.hardwareColor`
        """
        pass
    def getHardwareShader(self):
        """
        Retrieves the value of the "hardwareShader" attribute of a layered shader node.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.hardwareShader`
        """
        pass
    def getTransparency(self, lIndex='0'):
        """
        Retrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.
        
        Parameters:
        lIndex : 'int'
            Index of the shader's entry in the inputs attribute array element.
        
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.transparency`
        """
        pass
    def setColor(self, col, lIndex='0'):
        """
        Sets the value of the "color" attribute of a shader node.
        
        Parameters:
        col : 'Color'
            Color.
        lIndex : 'int'
            Index of the shader's entry in the
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.setColor`
        """
        pass
    def setCompositingFlag(self, cflag):
        """
        Sets the value of the "compositingFlag" attribute of a shader node.
        
        Parameters:
        cflag : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.setCompositingFlag`
        """
        pass
    def setGlowColor(self, glow_color, lIndex='0'):
        """
        Sets the value of the "glowColor" attribute of a shader node.
        
        Parameters:
        glow_color : 'Color'
            Color to which the attribute will be set.
        lIndex : 'int'
            Index of the shader's entry in the
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.setGlowColor`
        """
        pass
    def setHardwareColor(self, hardware_color):
        """
        Sets the value of the "hardwareColor" attribute of a shader node.
        
        Parameters:
        hardware_color : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.setHardwareColor`
        """
        pass
    def setHardwareShader(self, hardware_shader):
        """
        Sets the value of the "hardwareShader" attribute of a shader node.
        
        Parameters:
        hardware_shader : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.setHardwareShader`
        """
        pass
    def setTransparency(self, transp, lIndex='0'):
        """
        Sets the value of the "transparency" attribute of a shader node.
        
        Parameters:
        transp : 'Color'
            Value to which the attribute will be set.
        lIndex : 'int'
            Index of the shader's entry in the
        
        Derived from api method `maya.OpenMaya.MFnLayeredShader.setTransparency`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiBump3d(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeIllustratorCurves(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class EulerToQuat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiRaySwitch(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiVolumeSampleFloat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BaseShadingSwitch(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorConstant(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiPow(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditive(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class FilletCurve(AbstractBaseCreate):
    def getBias(self, **kwargs):
        """
        Adjusting the bias value causes the fillet curve to be skewed to one of the input curves. Available only if blendControl is true. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getBlendControl(self, **kwargs):
        """
        If true then depth and bias can be controlled. Otherwise, depth and bias are not available options. Default:false                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getCircular(self, **kwargs):
        """
        Curve fillet will be created as circular if true or freeform if false. Default:true                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getCurveParameter1(self, **kwargs):
        """
        Parameter where fillet curve will contact the primary input curve. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getCurveParameter2(self, **kwargs):
        """
        Parameter where fillet curve will contact the secondary input curve. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getDepth(self, **kwargs):
        """
        Adjusts the depth of the fillet curve. Available only if blendControl is true. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getFreeformBlend(self, **kwargs):
        """
        The freeform type is blend if true or tangent if false. Available if the fillet type is freeform. Default:false                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def getRadius(self, **kwargs):
        """
        The radius if creating a circular fillet. Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setBias(self, val='True', **kwargs):
        """
        Adjusting the bias value causes the fillet curve to be skewed to one of the input curves. Available only if blendControl is true. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setBlendControl(self, val='True', **kwargs):
        """
        If true then depth and bias can be controlled. Otherwise, depth and bias are not available options. Default:false                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setCircular(self, val='True', **kwargs):
        """
        Curve fillet will be created as circular if true or freeform if false. Default:true                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setCurveParameter1(self, val='True', **kwargs):
        """
        Parameter where fillet curve will contact the primary input curve. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setCurveParameter2(self, val='True', **kwargs):
        """
        Parameter where fillet curve will contact the secondary input curve. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setDepth(self, val='True', **kwargs):
        """
        Adjusts the depth of the fillet curve. Available only if blendControl is true. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setFreeformBlend(self, val='True', **kwargs):
        """
        The freeform type is blend if true or tangent if false. Available if the fillet type is freeform. Default:false                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        The radius if creating a circular fillet. Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The curve fillet command creates a fillet curve between two curves. If no
        objects are specified in the command line, then the first two active curves are
        used. The fillet created can be circular (with a radius) or freeform (with a
        type of tangent or blend).
        
        Flags:
        - bias : b                       (float)         [create,query,edit]
            Adjusting the bias value causes the fillet curve to be skewed to one of the
            input curves. Available only if blendControl is true. Default:0.0
        
        - blendControl : bc              (bool)          [create,query,edit]
            If true then depth and bias can be controlled. Otherwise, depth and bias are not
            available options. Default:false
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - circular : cir                 (bool)          [create,query,edit]
            Curve fillet will be created as circular if true or freeform if false.
            Default:true
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curveParameter1 : cp1          (float)         [create,query,edit]
            Parameter where fillet curve will contact the primary input curve. Default:0.0
        
        - curveParameter2 : cp2          (float)         [create,query,edit]
            Parameter where fillet curve will contact the secondary input curve. Default:0.0
        
        - depth : d                      (float)         [create,query,edit]
            Adjusts the depth of the fillet curve. Available only if blendControl is true.
            Default:0.5
        
        - freeformBlend : fb             (bool)          [create,query,edit]
            The freeform type is blend if true or tangent if false. Available if the fillet
            type is freeform. Default:false
        
        - frozen : fzn                   (bool)          []
        
        - join : jn                      (bool)          [create]
            Should the fillet be joined?
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - radius : r                     (float)         [create,query,edit]
            The radius if creating a circular fillet. Default:1.0                  Common
            flags
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).
        
        - trim : t                       (bool)          [create]
            Should the fillet be trimmed?                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.filletCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PointOnSurfaceInfo(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class DetachSurface(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def getDirection(self, **kwargs):
        """
        Direction in which to detach: 0 - V direction, 1 - U direction Default:1                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def getKeep(self, **kwargs):
        """
        Keep the detached pieces. Default:true                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def getParameter(self, **kwargs):
        """
        Parameter at which to detach. Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        Direction in which to detach: 0 - V direction, 1 - U direction Default:1                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def setKeep(self, val='True', **kwargs):
        """
        Keep the detached pieces. Default:true                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        Parameter at which to detach. Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The detachSurface command detaches a surface into pieces, given a list of
        parameter values and a direction.  You can also specify which pieces to keep and
        which to discard using the -kflag. The names of the newly detached surface(s)
        are returned.  If history is on, the name of the resulting dependency node is
        also returned. You can only detach in either U or V (not both) with a single
        detachSurface operation. You can use this command to open a closed surface at a
        particular parameter value.  You would use this command with only one -pflag. If
        you are specifying -kflags, then you must specify one, none or all -kflags.  If
        you are specifying all -kflags, there must be one more -kflag than -pflags.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - direction : d                  (int)           [create,query,edit]
            Direction in which to detach: 0 - V direction, 1 - U direction Default:1
        
        - frozen : fzn                   (bool)          []
        
        - keep : k                       (bool)          [create,query,edit]
            Keep the detached pieces. Default:true
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            Parameter at which to detach. Default:0.0                  Common flags
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.detachSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ShadingMap(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeTime(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMerge(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FfBlendSrfObsolete(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSqrt(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveTA(AnimCurve):
    def addKey(self, time, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        time : 'Time'
            Time at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Bump2d(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatAdd(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BossEXRInfluence(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiWriteInt(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUserDataColor(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BoneLattice(GeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getBicep(self, **kwargs):
        """
        Affects the bulging of lattice points on the inside of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getJoint(self, **kwargs):
        """
        Specifies which joint will be used to drive the bulging behaviors.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getLengthIn(self, **kwargs):
        """
        Affects the location of lattice points along the upper half of the bone. Positive/negative values cause the points to move away/towards the center of the bone.  Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getLengthOut(self, **kwargs):
        """
        Affects the location of lattice points along the lower half of the bone. Positive/negative values cause the points to move away/towards the center of the bone.  Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getTricep(self, **kwargs):
        """
        Affects the bulging of lattice points on the outside of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getWidthLeft(self, **kwargs):
        """
        Affects the bulging of lattice points on the left side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def getWidthRight(self, **kwargs):
        """
        Affects the bulging of lattice points on the right side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setBicep(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the inside of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setJoint(self, val='True', **kwargs):
        """
        Specifies which joint will be used to drive the bulging behaviors.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setLengthIn(self, val='True', **kwargs):
        """
        Affects the location of lattice points along the upper half of the bone. Positive/negative values cause the points to move away/towards the center of the bone.  Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setLengthOut(self, val='True', **kwargs):
        """
        Affects the location of lattice points along the lower half of the bone. Positive/negative values cause the points to move away/towards the center of the bone.  Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setTricep(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the outside of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setWidthLeft(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the left side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    def setWidthRight(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the right side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a boneLattice deformer. The name of the
        created/edited object is returned. Usually you would make use of this
        functionality through the higher level flexor command.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - bicep : bi                     (float)         [create,query,edit]
            Affects the bulging of lattice points on the inside of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - joint : j                      (unicode)       [create,query,edit]
            Specifies which joint will be used to drive the bulging behaviors.
        
        - lengthIn : li                  (float)         [create,query,edit]
            Affects the location of lattice points along the upper half of the bone.
            Positive/negative values cause the points to move away/towards the center of the
            bone.  Changing this parameter also modifies the regions affected by the
            creasing, rounding and width parameters. Default value is 0.0. When queried,
            this flag returns a float.
        
        - lengthOut : lo                 (float)         [create,query,edit]
            Affects the location of lattice points along the lower half of the bone.
            Positive/negative values cause the points to move away/towards the center of the
            bone.  Changing this parameter also modifies the regions affected by the
            creasing, rounding and width parameters. Default value is 0.0. When queried,
            this flag returns a float.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - transform : t                  (unicode)       [create]
            Specifies which dag node is being used to rigidly transform the lattice which
            this node is going to deform.  If this flag is not specified an identity matrix
            will be assumed.
        
        - tricep : tr                    (float)         [create,query,edit]
            Affects the bulging of lattice points on the outside of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.
        
        - widthLeft : wl                 (float)         [create,query,edit]
            Affects the bulging of lattice points on the left side of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.
        
        - widthRight : wr                (float)         [create,query,edit]
            Affects the bulging of lattice points on the right side of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.boneLattice`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMatrixMultiplyVector(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCurvature(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SmoothTangentSrf(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiShuffle(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Primitive(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAOVFilter(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HardenPoint(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class SimplexNoise(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAOVDriver(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPlatonic(THdependNode):
    """
    class counterpart of mel function `polyPlatonic`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - primitive : p                  (int)           []
        
        - radius : r                     (float)         []
        
        - sphericalInflation : i         (float)         []
        
        - subdivisionMode : sm           (int)           []
        
        - subdivisions : sd              (int)           []
        
        
        Derived from mel command `maya.cmds.polyPlatonic`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ProjectTangent(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getCurvature(self, **kwargs):
        """
        Curvature continuity is on if true and off otherwise. Default:false                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getCurvatureScale(self, **kwargs):
        """
        Curvature scale applied to curvature of curve to align. Available if curvature option is true. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getIgnoreEdges(self, **kwargs):
        """
        If false, use the tangents of the trim edge curves if the surface is trimmed. If true, use the tangents of the underlying surface in the U/V directions. Default:false                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getReverseTangent(self, **kwargs):
        """
        Reverse the tangent direction if true and leave it the way it is if false. Default:false                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getRotate(self, **kwargs):
        """
        Amount by which the tangent of the curve to align will be rotated. Available only if the normal direction (3) is not used for tangentDirection. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getTangentDirection(self, **kwargs):
        """
        Tangent align direction type legal values: 1=u direction (of surface or use first curve), 2=v direction (of surface or use second curve), 3=normal direction (at point of intersection). Default:1                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def getTangentScale(self, **kwargs):
        """
        Tangent scale applied to tangent of curve to align. Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setCurvature(self, val='True', **kwargs):
        """
        Curvature continuity is on if true and off otherwise. Default:false                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setCurvatureScale(self, val='True', **kwargs):
        """
        Curvature scale applied to curvature of curve to align. Available if curvature option is true. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setIgnoreEdges(self, val='True', **kwargs):
        """
        If false, use the tangents of the trim edge curves if the surface is trimmed. If true, use the tangents of the underlying surface in the U/V directions. Default:false                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setReverseTangent(self, val='True', **kwargs):
        """
        Reverse the tangent direction if true and leave it the way it is if false. Default:false                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setRotate(self, val='True', **kwargs):
        """
        Amount by which the tangent of the curve to align will be rotated. Available only if the normal direction (3) is not used for tangentDirection. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setTangentDirection(self, val='True', **kwargs):
        """
        Tangent align direction type legal values: 1=u direction (of surface or use first curve), 2=v direction (of surface or use second curve), 3=normal direction (at point of intersection). Default:1                  
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    def setTangentScale(self, val='True', **kwargs):
        """
        Tangent scale applied to tangent of curve to align. Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The project tangent command is used to align (for tangents) a curve to two other
        curves or a surface. A surface isoparm may be selected to define the direction
        (U or V) to align to. The end of the curve must intersect with these other
        objects. Curvature continuity may also be applied if required. Tangent
        continuity means the end of the curve is modified to be tangent at the point it
        meets the other objects. Curvature continuity means the end of the curve is
        modified to be curvature continuous as well as tangent. If the normal tangent
        direction is used, the curvature continuity and rotation do not apply. Also,
        curvature continuity is only available if align to a surface (not with 2
        curves).
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curvature : c                  (bool)          [create,query,edit]
            Curvature continuity is on if true and off otherwise. Default:false
        
        - curvatureScale : cs            (float)         [create,query,edit]
            Curvature scale applied to curvature of curve to align. Available if curvature
            option is true. Default:0.0
        
        - frozen : fzn                   (bool)          []
        
        - ignoreEdges : ie               (bool)          [create,query,edit]
            If false, use the tangents of the trim edge curves if the surface is trimmed. If
            true, use the tangents of the underlying surface in the U/V directions.
            Default:false
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - reverseTangent : rt            (bool)          [create,query,edit]
            Reverse the tangent direction if true and leave it the way it is if false.
            Default:false
        
        - rotate : ro                    (float)         [create,query,edit]
            Amount by which the tangent of the curve to align will be rotated. Available
            only if the normal direction (3) is not used for tangentDirection. Default:0.0
        
        - tangentDirection : td          (int)           [create,query,edit]
            Tangent align direction type legal values: 1=u direction (of surface or use
            first curve), 2=v direction (of surface or use second curve), 3=normal direction
            (at point of intersection). Default:1
        
        - tangentScale : ts              (float)         [create,query,edit]
            Tangent scale applied to tangent of curve to align. Default:1.0
            Common flags
        
        
        Derived from mel command `maya.cmds.projectTangent`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveFA(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiOptions(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Boolean(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCross(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ParticleSamplerInfo(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Breakout(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiThinFilm(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiToon(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiColorConvert(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BossGeoProperties(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAtmosphereVolume(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ComposeMatrix(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FloatLogic(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSwitch(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class LightFog(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class VectorExtrude(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyDisc(THdependNode):
    """
    class counterpart of mel function `polyDisc`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - radius : r                     (float)         []
        
        - sides : s                      (int)           []
        
        - subdivisionMode : sm           (int)           []
        
        - subdivisions : sd              (int)           []
        
        
        Derived from mel command `maya.cmds.polyDisc`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class InsertKnotCurve(AbstractBaseCreate):
    def getAddKnots(self, **kwargs):
        """
        Whether to add knots or complement.  Complement means knots will be added to reach the specified number of knots. Default:true                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def getInsertBetween(self, **kwargs):
        """
        If set to true, and there is more than one parameter value specified, the knots will get inserted at equally spaced intervals between the given parameter values, rather than at the parameter values themselves. Default:false                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def getNumberOfKnots(self, **kwargs):
        """
        How many knots to insert.  At any point on the curve, there can be a maximum of degreeknots. Default:1                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def getParameter(self, **kwargs):
        """
        Parameter value(s) where knots are added Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def setAddKnots(self, val='True', **kwargs):
        """
        Whether to add knots or complement.  Complement means knots will be added to reach the specified number of knots. Default:true                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def setInsertBetween(self, val='True', **kwargs):
        """
        If set to true, and there is more than one parameter value specified, the knots will get inserted at equally spaced intervals between the given parameter values, rather than at the parameter values themselves. Default:false                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def setNumberOfKnots(self, val='True', **kwargs):
        """
        How many knots to insert.  At any point on the curve, there can be a maximum of degreeknots. Default:1                  
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        Parameter value(s) where knots are added Default:0.0                  Common flags
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The insertKnotCurve command inserts knots into a curve given a list of parameter
        values. The number of knots to add at each parameter value and whether the knots
        are added or complemented can be specified. The name of the curve is returned.
        If construction history is on, the name of the resulting dependency node is also
        returned. An edit point will appear where you insert the knot. Also, the number
        of spans and CVs in the curve will increase in the area where the knot is
        inserted. You can insert up to degreeknots at a curve parameter that isn't
        already an edit point. eg. for a degree three curve, you can insert up to 3
        knots. Use this operation if you need more CVs in a local area of the curve. Use
        this operation (or hardenPoint) if you want to create a corner in a curve.
        
        Flags:
        - addKnots : add                 (bool)          [create,query,edit]
            Whether to add knots or complement.  Complement means knots will be added to
            reach the specified number of knots. Default:true
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curveOnSurface : cos           (bool)          [create]
            If possible, create 2D curve as a result.
        
        - frozen : fzn                   (bool)          []
        
        - insertBetween : ib             (bool)          [create,query,edit]
            If set to true, and there is more than one parameter value specified, the knots
            will get inserted at equally spaced intervals between the given parameter
            values, rather than at the parameter values themselves. Default:false
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - numberOfKnots : nk             (int)           [create,query,edit]
            How many knots to insert.  At any point on the curve, there can be a maximum of
            degreeknots. Default:1
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            Parameter value(s) where knots are added Default:0.0                  Common
            flags
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.insertKnotCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AdskPrepareRenderGlobals(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatSub(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class WeightGeometryFilter(GeometryFilter):
    def getWeightPlugStrings(self, list):
        """
        Set the plugStringArray argument to contain the names of the plugs on this node that correspond to the components in the selection list. The operation will fail if none of the items in the selection list correspond to components weighted by this cluster.
        
        Parameters:
        list : 'SelectionSet'
            selection list that contains components
        
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMayaAnim.MFnWeightGeometryFilter.getWeightPlugStrings`
        """
        pass
    def getWeights(self, index):
        """
        Gets the weights of the components that correspond to the geometry at the specified plug index.
        
        Parameters:
        index : 'int'
            the plug index corresponding to the shape that has the components
        
        
        Returns:
        Tuple['PyNode', List['float']]
        
        Derived from api method `maya.OpenMayaAnim.MFnWeightGeometryFilter.getWeights`
        """
        pass
    def setWeight(self, path, index, components, weight, oldValues='None'):
        """
        Sets the weights of the specified components of the object whose DAG path is specified.
        
        Parameters:
        path : 'PyNode'
            the DAG path for the object whose components' weights are being set
        index : 'int'
            the plug index for the specified shape
        components : 'PyNode'
            the components of the object
        weight : 'float'
            weight value for the components
        oldValues : List['float']
            an array of old values for the components
        
        Derived from api method `maya.OpenMayaAnim.MFnWeightGeometryFilter.setWeight`
        """
        pass
    def weightPlugStrings(self, list):
        """
        Sets the plugStrings argument to be a string (separated by spaces) containing the names of the plugs on this node that correspond to the components in the selection list. The method can be useful in conjunction with setting keys on a number of plugs. The operation will fail if none of the items in the selection list correspond to components weighted by this cluster.
        
        Parameters:
        list : 'SelectionSet'
            selection list that contains components
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMayaAnim.MFnWeightGeometryFilter.weightPlugStrings`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAtan(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiShadowMatte(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveTT(AnimCurve):
    def addKey(self, timeInput, timeValue, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given output time value and tangent types at the specified input time for curves of type kAnimCurveTT.
        
        Parameters:
        timeInput : 'Time'
            Time at which the key is to be added
        timeValue : 'Time'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTT at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLayerFloat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BossSpectralWave(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiColorToFloat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Legacy(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Wrap(GeometryFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class Texture2d(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiWriteColor(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiComplement(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveNormalizerLinear(CurveNormalizer):
    __melnode__ = []
    
    
    __readonly__ = {}


class BlendDevice(Blend):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Dynamics(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCarPaint(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveTU(AnimCurve):
    def addKey(self, time, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        time : 'Time'
            Time at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class IntersectSurface(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class Selector(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKState2GlobalSK(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatProd(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THarrayMapper(ArrayMapper):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiRandom(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THikSolverNode(IkSolver):
    __melnode__ = []
    
    
    __readonly__ = {}


class AxisAngleToQuat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveUA(AnimCurve):
    def addKey(self, unitlessInput, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified unitless input for curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU.
        
        Parameters:
        unitlessInput : 'float'
            Unitless input at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atUnitlessInput):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU at the specified unitless input.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, unitlessInput):
        """
        Determines the index of the key which is set at the time closest to the specified unitless input value.
        
        Parameters:
        unitlessInput : 'float'
            Input value for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveDA(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeCircularArc(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class FfBlendSrf(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class ExplodeNurbsShell(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCache(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdBlindData(PolyBlindData):
    __melnode__ = []
    
    
    __readonly__ = {}


class Place2dTexture(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class Tweak(GeometryFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMotionVector(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveIntersect(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def getDirection(self, **kwargs):
        """
        The direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        The X component of the direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        The Y component of the direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        The Z component of the direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance that the intersection is calculated with. For example, given two curves end-to-end, the ends must be within tolerance for an intersection to be returned. Default:0.001                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def getUseDirection(self, **kwargs):
        """
        If true, use direction flag.  The input curves are first projected in a specified direction and then intersected. If false, this command will only find true 3D intersections. Default:false                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        The direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        The X component of the direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        The Y component of the direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        The Z component of the direction that the input curves are projected in before intersecting.  This vector is only used if useDirectionflag is true.                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance that the intersection is calculated with. For example, given two curves end-to-end, the ends must be within tolerance for an intersection to be returned. Default:0.001                  
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    def setUseDirection(self, val='True', **kwargs):
        """
        If true, use direction flag.  The input curves are first projected in a specified direction and then intersected. If false, this command will only find true 3D intersections. Default:false                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        You must specify two curves to intersect. This command either returns the
        parameter values at which the given pair of curves intersect, or returns a
        dependency node that provides the intersection information. If you want to find
        the intersection of the curves in a specific direction you must use BOTH the
        -useDirectionflag and the directionflag.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - direction : d                  (float, float, float) [query,edit]
            The direction that the input curves are projected in before intersecting.  This
            vector is only used if useDirectionflag is true.
        
        - directionX : dx                (float)         [query,edit]
            The X component of the direction that the input curves are projected in before
            intersecting.  This vector is only used if useDirectionflag is true.
        
        - directionY : dy                (float)         [query,edit]
            The Y component of the direction that the input curves are projected in before
            intersecting.  This vector is only used if useDirectionflag is true.
        
        - directionZ : dz                (float)         [query,edit]
            The Z component of the direction that the input curves are projected in before
            intersecting.  This vector is only used if useDirectionflag is true.
        
        - frozen : fzn                   (bool)          []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - tolerance : tol                (float)         [query,edit]
            The tolerance that the intersection is calculated with. For example, given two
            curves end-to-end, the ends must be within tolerance for an intersection to be
            returned. Default:0.001
        
        - useDirection : ud              (bool)          [query,edit]
            If true, use direction flag.  The input curves are first projected in a
            specified direction and then intersected. If false, this command will only find
            true 3D intersections. Default:false                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.curveIntersect`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveUT(AnimCurve):
    def addKey(self, unitlessInput, timeValue, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given output time value and tangent types at the specified unitless input for curves of type kAnimCurveUT.
        
        Parameters:
        unitlessInput : 'float'
            Unitless input at which the key is to be added
        timeValue : 'Time'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atUnitlessInput):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveUT at the specified unitless input.
        
        Returns:
        Tuple['float', 'Time']
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, unitlessInput):
        """
        Determines the index of the key which is set at the time closest to the specified unitless input value.
        
        Parameters:
        unitlessInput : 'float'
            Input value for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderTarget(ImageSource):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiClamp(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveUL(AnimCurve):
    def addKey(self, unitlessInput, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified unitless input for curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU.
        
        Parameters:
        unitlessInput : 'float'
            Unitless input at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atUnitlessInput):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU at the specified unitless input.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, unitlessInput):
        """
        Determines the index of the key which is set at the time closest to the specified unitless input value.
        
        Parameters:
        unitlessInput : 'float'
            Input value for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleSmartConstraint(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorCondition(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DecomposeMatrix(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimCurveUU(AnimCurve):
    def addKey(self, unitlessInput, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified unitless input for curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU.
        
        Parameters:
        unitlessInput : 'float'
            Unitless input at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atUnitlessInput):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveUA, kAnimCurveUL and kAnimCurveUU at the specified unitless input.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, unitlessInput):
        """
        Determines the index of the key which is set at the time closest to the specified unitless input value.
        
        Parameters:
        unitlessInput : 'float'
            Input value for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class RotateHelper(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStateFloat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKProperty2State(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SurfaceInfo(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class HikSolver(IkSolver):
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmSplineBase(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorComposite(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CloseCurve(AbstractBaseCreate):
    def getBlendBias(self, **kwargs):
        """
        Skew the result toward the first or the second curve depending on the blend value being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def getBlendKnotInsertion(self, **kwargs):
        """
        If set to true, insert a knot in one of the original curves (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def getParameter(self, **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def getPreserveShape(self, **kwargs):
        """
        0 - without preserving the shape 1 - preserve shape 2 - blend Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def setBlendBias(self, val='True', **kwargs):
        """
        Skew the result toward the first or the second curve depending on the blend value being smaller or larger than 0.5. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def setBlendKnotInsertion(self, val='True', **kwargs):
        """
        If set to true, insert a knot in one of the original curves (relative position given by the parameter attribute below) in order to produce a slightly different effect. Default:false                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def setParameter(self, val='True', **kwargs):
        """
        The parameter value for the positioning of the newly inserted knot. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    def setPreserveShape(self, val='True', **kwargs):
        """
        0 - without preserving the shape 1 - preserve shape 2 - blend Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The closeCurve command closes a curve, making it periodic. The pathname to the
        newly closed curve and the name of the resulting dependency node are returned.
        If a curve is not specified in the command, then the first active curve will be
        used.
        
        Flags:
        - blendBias : bb                 (float)         [create,query,edit]
            Skew the result toward the first or the second curve depending on the blend
            value being smaller or larger than 0.5. Default:0.5
        
        - blendKnotInsertion : bki       (bool)          [create,query,edit]
            If set to true, insert a knot in one of the original curves (relative position
            given by the parameter attribute below) in order to produce a slightly different
            effect. Default:false
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - curveOnSurface : cos           (bool)          [create]
            If possible, create 2D curve as a result.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - parameter : p                  (float)         [create,query,edit]
            The parameter value for the positioning of the newly inserted knot. Default:0.1
        
        - preserveShape : ps             (int)           [create,query,edit]
            0 - without preserving the shape 1 - preserve shape 2 - blend Default:1
            Common flags
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.closeCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdHierBlind(BlindDataTemplate):
    __melnode__ = []
    
    
    __readonly__ = {}


class FloatMask(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class StitchSrf(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_PointToCurve(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMatte(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiComposite(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStandardSurface(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BlendTwoAttr(Blend):
    def getAttribute0(self, **kwargs):
        """
        The attribute that should be connected to the first input of the new blendTwoAttr node. When queried, it returns a string.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    def getAttribute1(self, **kwargs):
        """
        The attribute that should be connected to the second input of the new blendTwoAttr node. When queried, it returns a string.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    def getBlender(self, **kwargs):
        """
        The blender attribute. This is the attribute that will be connected to the newly created blendTwoAttr node(s) blender attribute. This attribute controls how much of each of the two attributes to use in the blend. If this flag is not specified, a new animation curve is created whose value goes from 1 to 0 throughout the time range specified by the -t flag. If -t is not specified, an abrupt change from the value of the first to the value of the second attribute will occur at the current time when this command is issued.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    def getDriver(self, **kwargs):
        """
        The index of the driver attribute for this blend node (0 or 1) When queried, it returns an integer.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    def setAttribute0(self, val='True', **kwargs):
        """
        The attribute that should be connected to the first input of the new blendTwoAttr node. When queried, it returns a string.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    def setAttribute1(self, val='True', **kwargs):
        """
        The attribute that should be connected to the second input of the new blendTwoAttr node. When queried, it returns a string.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    def setBlender(self, val='True', **kwargs):
        """
        The blender attribute. This is the attribute that will be connected to the newly created blendTwoAttr node(s) blender attribute. This attribute controls how much of each of the two attributes to use in the blend. If this flag is not specified, a new animation curve is created whose value goes from 1 to 0 throughout the time range specified by the -t flag. If -t is not specified, an abrupt change from the value of the first to the value of the second attribute will occur at the current time when this command is issued.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    def setDriver(self, val='True', **kwargs):
        """
        The index of the driver attribute for this blend node (0 or 1) When queried, it returns an integer.                  
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        A blendTwoAttr nodes takes two inputs, and blends the values of the inputs from
        one to the other, into an output value. The blending of the two inputs uses a
        blending function, and the following formula: (1 - blendFunction) \* input[0]  +
        blendFunction \* input[1] The blendTwoAttr command can be used to blend the
        animation of an object to transition smoothly between the animation of two other
        objects. When the blendTwoAttr command is issued, it creates a blendTwoAttr node
        on the specified attributes, and reconnects whatever was previously connected to
        the attributes to the new blend nodes. You may also specify which two attributes
        should be used to blend together. The driver is used when you want to keyframe
        an object after it is being animated by a blend node. The current driver index
        specifies which of the two blended attributes should be keyframed.
        
        Flags:
        - attribute : at                 (unicode)       [create]
            A list of attributes for the selected nodes for which a blendTwoAttr node will
            be created.
        
        - attribute0 : at0               (PyNode)        [create,query,edit]
            The attribute that should be connected to the first input of the new
            blendTwoAttr node. When queried, it returns a string.
        
        - attribute1 : at1               (PyNode)        [create,query,edit]
            The attribute that should be connected to the second input of the new
            blendTwoAttr node. When queried, it returns a string.
        
        - blender : bl                   (PyNode)        [create,query,edit]
            The blender attribute. This is the attribute that will be connected to the newly
            created blendTwoAttr node(s) blender attribute. This attribute controls how much
            of each of the two attributes to use in the blend. If this flag is not
            specified, a new animation curve is created whose value goes from 1 to 0
            throughout the time range specified by the -t flag. If -t is not specified, an
            abrupt change from the value of the first to the value of the second attribute
            will occur at the current time when this command is issued.
        
        - controlPoints : cp             (bool)          [create]
            Explicitly specify whether or not to include the control points of a shape (see
            -sflag) in the list of attributes. Default: false.
        
        - driver : d                     (int)           [create,query,edit]
            The index of the driver attribute for this blend node (0 or 1) When queried, it
            returns an integer.
        
        - name : n                       (unicode)       [create,query]
            name for the new blend node(s)
        
        - shape : s                      (bool)          [create]
            Consider all attributes of shapes below transforms as well, except
            controlPoints. Default: true
        
        - time : t                       (timerange)     [create]
            The time range between which the blending between the 2 attributes should occur.
            If a single time is specified, then the blend will cause an abrupt change from
            the first to the second attribute at that time.  If a range is specified, a
            smooth blending will occur over that time range. The default is to make a sudden
            transition at the current time.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.blendTwoAttr`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TransposeMatrix(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiTwoSided(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiTraceSet(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLightDecay(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FloatConstant(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OffsetCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getConnectBreaks(self, **kwargs):
        """
        Connect breaks method (between gaps): 0 - off, 1 - circular, 2 - linear Default:2                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getCutLoop(self, **kwargs):
        """
        Do loop cutting. Default:false                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getCutRadius(self, **kwargs):
        """
        Loop cut radius. Only used if cutLoop attribute is set true. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getDistance(self, **kwargs):
        """
        Offset distance Default:1.0                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getNormal(self, **kwargs):
        """
        Offset plane normal                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getReparameterize(self, **kwargs):
        """
        Do reparameterization. It is not advisable to change this value. Default:false                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getStitch(self, **kwargs):
        """
        Stitch curve segments together. It is not advisable to change this value. Default:true                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getSubdivisionDensity(self, **kwargs):
        """
        Maximum subdivision density per span Default:5                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        Tolerance Default:0.01                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def getUseGivenNormal(self, **kwargs):
        """
        Use the given normal (or, alternativelly, geometry normal) Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setConnectBreaks(self, val='True', **kwargs):
        """
        Connect breaks method (between gaps): 0 - off, 1 - circular, 2 - linear Default:2                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setCutLoop(self, val='True', **kwargs):
        """
        Do loop cutting. Default:false                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setCutRadius(self, val='True', **kwargs):
        """
        Loop cut radius. Only used if cutLoop attribute is set true. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setDistance(self, val='True', **kwargs):
        """
        Offset distance Default:1.0                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setNormal(self, val='True', **kwargs):
        """
        Offset plane normal                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setReparameterize(self, val='True', **kwargs):
        """
        Do reparameterization. It is not advisable to change this value. Default:false                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setStitch(self, val='True', **kwargs):
        """
        Stitch curve segments together. It is not advisable to change this value. Default:true                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setSubdivisionDensity(self, val='True', **kwargs):
        """
        Maximum subdivision density per span Default:5                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        Tolerance Default:0.01                  
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    def setUseGivenNormal(self, val='True', **kwargs):
        """
        Use the given normal (or, alternativelly, geometry normal) Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The offset command creates new offset curves from the selected curves. The
        connecting type for breaks in offsets is off (no connection), circular (connect
        with an arc) or linear (connect linearly resulting in a sharp corner). If loop
        cutting is on then any loops in the offset curves are trimmed away. For the
        default cut radius of 0.0 a sharp corner is created at each intersection. For
        values greater than 0.0 a small arc of that radius is created at each
        intersection. The cut radius value is only valid when loop cutting is on.
        Offsets (for planar curves) are calculated in the plane of that curve and 3d
        curves are offset in 3d. The subdivisionDensity flag is the maximum number of
        times the offset object can be subdivided (i.e. calculate the offset until the
        offset comes within tolerance or the iteration reaches this maximum.) The
        reparameterize option allows the offset curve to have a different
        parameterization to the original curve. This avoids uneven parameter
        distributions in the offset curve that can occur with large offsets of curves,
        but is more expensive to compute.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - connectBreaks : cb             (int)           [create,query,edit]
            Connect breaks method (between gaps): 0 - off, 1 - circular, 2 - linear
            Default:2
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - cutLoop : cl                   (bool)          [create,query,edit]
            Do loop cutting. Default:false
        
        - cutRadius : cr                 (float)         [create,query,edit]
            Loop cut radius. Only used if cutLoop attribute is set true. Default:0.0
        
        - distance : d                   (float)         [create,query,edit]
            Offset distance Default:1.0
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - normal : nr                    (float, float, float) [create,query,edit]
            Offset plane normal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - reparameterize : rp            (bool)          [create,query,edit]
            Do reparameterization. It is not advisable to change this value. Default:false
        
        - stitch : st                    (bool)          [create,query,edit]
            Stitch curve segments together. It is not advisable to change this value.
            Default:true
        
        - subdivisionDensity : sd        (int)           [create,query,edit]
            Maximum subdivision density per span Default:5
        
        - tolerance : tol                (float)         [create,query,edit]
            Tolerance Default:0.01
        
        - useGivenNormal : ugn           (bool)          [create,query,edit]
            Use the given normal (or, alternativelly, geometry normal) Default:1
            Common flags
        
        
        Derived from mel command `maya.cmds.offsetCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSpaceTransform(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FloatMath(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCreator(PolyBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyGear(THdependNode):
    """
    class counterpart of mel function `polyGear`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - gearMiddle : gm                (float)         []
        
        - gearOffset : go                (float)         []
        
        - gearSpacing : gs               (float)         []
        
        - gearTip : gt                   (float)         []
        
        - height : h                     (float)         []
        
        - heightDivisions : hd           (int)           []
        
        - internalRadius : ir            (float)         []
        
        - radius : r                     (float)         []
        
        - sides : s                      (int)           []
        
        - taper : ta                     (float)         []
        
        - twist : t                      (float)         []
        
        
        Derived from mel command `maya.cmds.polyGear`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HwShader(ShadingDependNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiWireframe(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiTrigo(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStateVector(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiComplexIor(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ColorMask(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ListItem(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BifrostAttrNotifier(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStateInt(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class LeastSquaresModifier(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class BoundaryBase(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class BifrostFoamMaterial(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeTextCurves(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Trails(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUserDataVector(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiColorCorrect(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMatrixTransform(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FloatCorrect(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiReciprocal(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Lambert(ShadingDependNode):
    def getAmbientColor(self):
        """
        Retrieves the value of the "ambientColor" attribute of a shader node. This attribute represents the ambient color of the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.ambientColor`
        """
        pass
    def getColor(self):
        """
        Retrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.color`
        """
        pass
    def getDiffuseCoeff(self):
        """
        Retrieves the value of the "diffuseCoeff" attribute of a lambert shader node. This attribute represents the diffuse reflectivity of the shader.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.diffuseCoeff`
        """
        pass
    def getGlowIntensity(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.glowIntensity`
        """
        pass
    def getHideSource(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.hideSource`
        """
        pass
    def getIncandescence(self):
        """
        Retrieves the value of the "incandescence" attribute of a shader node. This attribute represents the incandescence of the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.incandescence`
        """
        pass
    def getRefractedRayDepthLimit(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.refractedRayDepthLimit`
        """
        pass
    def getRefractiveIndex(self):
        """
        Retrieves the value of the "refractiveIndex" attribute of a lambert shader node. This attribute represents the refractive index of the shader.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.refractiveIndex`
        """
        pass
    def getRtRefractedColor(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.rtRefractedColor`
        """
        pass
    def getTranslucenceCoeff(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.translucenceCoeff`
        """
        pass
    def getTransparency(self):
        """
        Retrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.transparency`
        """
        pass
    def setAmbientColor(self, ambient_color):
        """
        Sets the value of the "ambientColor" attribute of a shader node.
        
        Parameters:
        ambient_color : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setAmbientColor`
        """
        pass
    def setColor(self, col):
        """
        Sets the value of the "color" attribute of a shader node.
        
        Parameters:
        col : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setColor`
        """
        pass
    def setDiffuseCoeff(self, diffuse_coeff):
        """
        Sets the value of the "diffuseCoeff" attribute of a shader node.
        
        Parameters:
        diffuse_coeff : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setDiffuseCoeff`
        """
        pass
    def setGlowIntensity(self, glow_intensity):
        """
        Sets the value of the "glowIntensity" attribute of a shader node.
        
        Parameters:
        glow_intensity : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setGlowIntensity`
        """
        pass
    def setHideSource(self, hide_source):
        """
        Sets the value of the "hideSource" attribute of a shader node.
        
        Parameters:
        hide_source : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setHideSource`
        """
        pass
    def setIncandescence(self, incand):
        """
        Sets the value of the "incandescence" attribute of a shader node.
        
        Parameters:
        incand : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setIncandescence`
        """
        pass
    def setRefractedRayDepthLimit(self, refracted_ray_depth_limit):
        """
        Sets the value of the "refractedRayDepthLimit" attribute of a lambert shader node.
        
        Parameters:
        refracted_ray_depth_limit : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setRefractedRayDepthLimit`
        """
        pass
    def setRefractiveIndex(self, refractive_index):
        """
        Sets the value of the "refractiveIndex" attribute of a shader node.
        
        Parameters:
        refractive_index : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setRefractiveIndex`
        """
        pass
    def setRtRefractedColor(self, rt_refracted_color):
        """
        Sets the value of the "rtRefractedColor" attribute of a shader node.
        
        Parameters:
        rt_refracted_color : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setRtRefractedColor`
        """
        pass
    def setTranslucenceCoeff(self, translucence_coeff):
        """
        Sets the value of the "translucenceCoeff" attribute of a shader node.
        
        Parameters:
        translucence_coeff : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setTranslucenceCoeff`
        """
        pass
    def setTransparency(self, transp):
        """
        Sets the value of the "transparency" attribute of a shader node.
        
        Parameters:
        transp : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLambertShader.setTransparency`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiImage(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbsSquare(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getCenter(self, **kwargs):
        """
        The center point of the square.                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getCenterX(self, **kwargs):
        """
        X of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getCenterY(self, **kwargs):
        """
        Y of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getCenterZ(self, **kwargs):
        """
        Z of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting circle: 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getNormal(self, **kwargs):
        """
        The normal of the plane in which the square will lie.                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getNormalX(self, **kwargs):
        """
        X of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getNormalY(self, **kwargs):
        """
        Y of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getNormalZ(self, **kwargs):
        """
        Z of the normal direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getSideLength1(self, **kwargs):
        """
        The length of a side on the square. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getSideLength2(self, **kwargs):
        """
        The length of an adjacent side on the square. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def getSpansPerSide(self, **kwargs):
        """
        The number of spans per side determines the resolution of the square. Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setCenter(self, val='True', **kwargs):
        """
        The center point of the square.                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setCenterX(self, val='True', **kwargs):
        """
        X of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setCenterY(self, val='True', **kwargs):
        """
        Y of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setCenterZ(self, val='True', **kwargs):
        """
        Z of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting circle: 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setNormal(self, val='True', **kwargs):
        """
        The normal of the plane in which the square will lie.                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setNormalX(self, val='True', **kwargs):
        """
        X of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setNormalY(self, val='True', **kwargs):
        """
        Y of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setNormalZ(self, val='True', **kwargs):
        """
        Z of the normal direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setSideLength1(self, val='True', **kwargs):
        """
        The length of a side on the square. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setSideLength2(self, val='True', **kwargs):
        """
        The length of an adjacent side on the square. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    def setSpansPerSide(self, val='True', **kwargs):
        """
        The number of spans per side determines the resolution of the square. Default:1                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The nurbsSquare command creates a square
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - center : c                     (float, float, float) [create,query,edit]
            The center point of the square.
        
        - centerX : cx                   (float)         [create,query,edit]
            X of the center point. Default:0
        
        - centerY : cy                   (float)         [create,query,edit]
            Y of the center point. Default:0
        
        - centerZ : cz                   (float)         [create,query,edit]
            Z of the center point. Default:0
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting circle: 1 - linear, 2 - quadratic, 3 - cubic, 5 -
            quintic, 7 - heptic Default:3
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - normal : nr                    (float, float, float) [create,query,edit]
            The normal of the plane in which the square will lie.
        
        - normalX : nrx                  (float)         [create,query,edit]
            X of the normal direction. Default:0
        
        - normalY : nry                  (float)         [create,query,edit]
            Y of the normal direction. Default:0
        
        - normalZ : nrz                  (float)         [create,query,edit]
            Z of the normal direction. Default:1
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - sideLength1 : sl1              (float)         [create,query,edit]
            The length of a side on the square. Default:1.0
        
        - sideLength2 : sl2              (float)         [create,query,edit]
            The length of an adjacent side on the square. Default:1.0
        
        - spansPerSide : sps             (int)           [create,query,edit]
            The number of spans per side determines the resolution of the square. Default:1
            Common flags
        
        
        Derived from mel command `maya.cmds.nurbsSquare`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'nurbsSquare'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class IkSCsolver(IkSolver):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStandardHair(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiNoise(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Revolve(AbstractBaseCreate):
    def getAutoCorrectNormal(self, **kwargs):
        """
        If this is set to true we will attempt to reverse the direction of the axis in case it is necessary to do so for the surface normals to end up pointing to the outside of the object. Default:false                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getAxis(self, **kwargs):
        """
        Revolve axis                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getAxisChoice(self, **kwargs):
        """
        Only used for computed axis/pivot case.  As we are computing the axis for a planar curve, we have two choices for the major axis based axis.  We will choose the axis corresponding to the longer dimension of the object (0), or explicitly choose one or the other (choices 1 and 2). Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getAxisX(self, **kwargs):
        """
        X of the axis Default:1                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getAxisY(self, **kwargs):
        """
        Y of the axis Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getAxisZ(self, **kwargs):
        """
        Z of the axis Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getBridge(self, **kwargs):
        """
        If true, we will close a partial revolve to get a pie shaped surface.  The surface will be closed, but not periodic the way it is in the full revolve case. Default:false                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getComputePivotAndAxis(self, **kwargs):
        """
        If this is set to 2, we will compute the axis, use the curve position and radius to compute the pivot for the revolve internally.  The value of the pivot and axis attributes are ignored.  If this is set to 1, we will take the supplied axis, but compute the pivot.  If this is set to 0, we will take both the supplied axis and pivot. Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface. Default:3                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getEndSweep(self, **kwargs):
        """
        The value for the end sweep angle, in the current units.  This must be no more than the maximum, 360 degrees, or 2 Pi radians. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getPivot(self, **kwargs):
        """
        Revolve pivot point                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getPivotX(self, **kwargs):
        """
        X of the pivot Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getPivotY(self, **kwargs):
        """
        Y of the pivot Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getPivotZ(self, **kwargs):
        """
        Z of the pivot Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getRadius(self, **kwargs):
        """
        The pivot point will be this distance away from the bounding box of the curve, if computedPivot is set to true.  The value of the pivot attribute is ignored. Default:1                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getRadiusAnchor(self, **kwargs):
        """
        The position on the curve for the anchor point so that we can compute the pivot using the radius value.  If in 0 - 1 range, its on the curve, normalized parameter range.  If 0 or 1, its computed based on the bounding box. Default:-1                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getSections(self, **kwargs):
        """
        Number of sections of the resulting surface (if tolerance is not used). Default:8                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getStartSweep(self, **kwargs):
        """
        The value for the start sweep angle, in the current units.  This must be no more than the maximum, 360 degrees, or 2 Pi radians. Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        Tolerance to build to (if useTolerance attribute is set) Default:0.01                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getUseLocalPivot(self, **kwargs):
        """
        If true, then the pivot of the profile curve is used as the start point of the axis of revolution.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def getUseTolerance(self, **kwargs):
        """
        Use the tolerance, or the number of sections to control the sections. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setAutoCorrectNormal(self, val='True', **kwargs):
        """
        If this is set to true we will attempt to reverse the direction of the axis in case it is necessary to do so for the surface normals to end up pointing to the outside of the object. Default:false                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        Revolve axis                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setAxisChoice(self, val='True', **kwargs):
        """
        Only used for computed axis/pivot case.  As we are computing the axis for a planar curve, we have two choices for the major axis based axis.  We will choose the axis corresponding to the longer dimension of the object (0), or explicitly choose one or the other (choices 1 and 2). Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setAxisX(self, val='True', **kwargs):
        """
        X of the axis Default:1                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setAxisY(self, val='True', **kwargs):
        """
        Y of the axis Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setAxisZ(self, val='True', **kwargs):
        """
        Z of the axis Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setBridge(self, val='True', **kwargs):
        """
        If true, we will close a partial revolve to get a pie shaped surface.  The surface will be closed, but not periodic the way it is in the full revolve case. Default:false                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setComputePivotAndAxis(self, val='True', **kwargs):
        """
        If this is set to 2, we will compute the axis, use the curve position and radius to compute the pivot for the revolve internally.  The value of the pivot and axis attributes are ignored.  If this is set to 1, we will take the supplied axis, but compute the pivot.  If this is set to 0, we will take both the supplied axis and pivot. Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface. Default:3                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setEndSweep(self, val='True', **kwargs):
        """
        The value for the end sweep angle, in the current units.  This must be no more than the maximum, 360 degrees, or 2 Pi radians. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        Revolve pivot point                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setPivotX(self, val='True', **kwargs):
        """
        X of the pivot Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setPivotY(self, val='True', **kwargs):
        """
        Y of the pivot Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setPivotZ(self, val='True', **kwargs):
        """
        Z of the pivot Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        The pivot point will be this distance away from the bounding box of the curve, if computedPivot is set to true.  The value of the pivot attribute is ignored. Default:1                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setRadiusAnchor(self, val='True', **kwargs):
        """
        The position on the curve for the anchor point so that we can compute the pivot using the radius value.  If in 0 - 1 range, its on the curve, normalized parameter range.  If 0 or 1, its computed based on the bounding box. Default:-1                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setSections(self, val='True', **kwargs):
        """
        Number of sections of the resulting surface (if tolerance is not used). Default:8                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setStartSweep(self, val='True', **kwargs):
        """
        The value for the start sweep angle, in the current units.  This must be no more than the maximum, 360 degrees, or 2 Pi radians. Default:0                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        Tolerance to build to (if useTolerance attribute is set) Default:0.01                  
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setUseLocalPivot(self, val='True', **kwargs):
        """
        If true, then the pivot of the profile curve is used as the start point of the axis of revolution.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    def setUseTolerance(self, val='True', **kwargs):
        """
        Use the tolerance, or the number of sections to control the sections. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a revolved surface by revolving the given profile curve
        about an axis.  The profile curve can be a curve, curve-on-surface, surface
        isoparm, or trim edge.
        
        Flags:
        - autoCorrectNormal : acn        (bool)          [create,query,edit]
            If this is set to true we will attempt to reverse the direction of the axis in
            case it is necessary to do so for the surface normals to end up pointing to the
            outside of the object. Default:false
        
        - axis : ax                      (float, float, float) [create,query,edit]
            Revolve axis
        
        - axisChoice : aco               (int)           [create,query,edit]
            Only used for computed axis/pivot case.  As we are computing the axis for a
            planar curve, we have two choices for the major axis based axis.  We will choose
            the axis corresponding to the longer dimension of the object (0), or explicitly
            choose one or the other (choices 1 and 2). Default:0
        
        - axisX : axx                    (float)         [create,query,edit]
            X of the axis Default:1
        
        - axisY : axy                    (float)         [create,query,edit]
            Y of the axis Default:0
        
        - axisZ : axz                    (float)         [create,query,edit]
            Z of the axis Default:0
        
        - bridge : br                    (bool)          [create,query,edit]
            If true, we will close a partial revolve to get a pie shaped surface.  The
            surface will be closed, but not periodic the way it is in the full revolve case.
            Default:false
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - computePivotAndAxis : cpa      (int)           [create,query,edit]
            If this is set to 2, we will compute the axis, use the curve position and radius
            to compute the pivot for the revolve internally.  The value of the pivot and
            axis attributes are ignored.  If this is set to 1, we will take the supplied
            axis, but compute the pivot.  If this is set to 0, we will take both the
            supplied axis and pivot. Default:0
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface. Default:3
        
        - endSweep : esw                 (float)         [create,query,edit]
            The value for the end sweep angle, in the current units.  This must be no more
            than the maximum, 360 degrees, or 2 Pi radians. Default:6.2831853
        
        - frozen : fzn                   (bool)          []
        
        - mergeItems : mi                (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - pivot : p                      (float, float, float) [create,query,edit]
            Revolve pivot point
        
        - pivotX : px                    (float)         [create,query,edit]
            X of the pivot Default:0
        
        - pivotY : py                    (float)         [create,query,edit]
            Y of the pivot Default:0
        
        - pivotZ : pz                    (float)         [create,query,edit]
            Z of the pivot Default:0
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)
        
        - radius : r                     (float)         [create,query,edit]
            The pivot point will be this distance away from the bounding box of the curve,
            if computedPivot is set to true.  The value of the pivot attribute is ignored.
            Default:1
        
        - radiusAnchor : ra              (float)         [create,query,edit]
            The position on the curve for the anchor point so that we can compute the pivot
            using the radius value.  If in 0 - 1 range, its on the curve, normalized
            parameter range.  If 0 or 1, its computed based on the bounding box. Default:-1
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.
        
        - rebuild : rb                   (bool)          [create]
            Rebuild the input curve(s) before using them in the operation.  Use
            nurbsCurveRebuildPref to set the parameters for the conversion.
        
        - sections : s                   (int)           [create,query,edit]
            Number of sections of the resulting surface (if tolerance is not used).
            Default:8
        
        - startSweep : ssw               (float)         [create,query,edit]
            The value for the start sweep angle, in the current units.  This must be no more
            than the maximum, 360 degrees, or 2 Pi radians. Default:0
        
        - tolerance : tol                (float)         [create,query,edit]
            Tolerance to build to (if useTolerance attribute is set) Default:0.01
        
        - useLocalPivot : ulp            (bool)          [create,query,edit]
            If true, then the pivot of the profile curve is used as the start point of the
            axis of revolution.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        - useTolerance : ut              (bool)          [create,query,edit]
            Use the tolerance, or the number of sections to control the sections.
            Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.revolve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Inherit(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKSK2State(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CacheFile(CacheBase):
    def getCacheFormat(self, **kwargs):
        """
        Cache file format, default is Maya's .mcx format, but others available via plugin                                  
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getCacheInfo(self, **kwargs):
        """
        In create mode, used to specify a mel script returning a string array. When creating the cache, this mel script will be executed and the returned strings will be written to the .xml description file of the cache. In query mode, returns descriptive info stored in the cacheFile such as the user name, Maya scene name and maya version number.                               
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getCacheableAttrs(self, **kwargs):
        """
        Returns the list of cacheable attributes defined on the accompanying cache node. This argument requires the use of the cacheableNode flag.                                 
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getChannelIndex(self, **kwargs):
        """
        A query-only flag which returns the channel index for the selected geometry for the cacheFile node specified using the cacheFileNode flag.                                 
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getChannelName(self, **kwargs):
        """
        When attachFile is used, used to indicate the channel in the file that should be attached to inAttr.  If not specified, the first channel in the file is used. In query mode, allows user to query the channels associated with a description file.                                
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getDataSize(self, **kwargs):
        """
        This is a query-only flag that returns the size of the data being cached per frame. This flag is to be used in conjunction with the cacheableNode, points, pointsAndNormals and outAttr flags.                             
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getDescriptionFileName(self, **kwargs):
        """
        This is a query-only flag that returns the name of the description file for an existing cacheFile node. Or if no cacheFile node is specified, it returns the description file name that would be created based on the other flags specified.                               
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getDirectory(self, **kwargs):
        """
        Specifies the directory where the cache files will be located. If the directory flag is not specified, the cache files will be placed in the project data directory.                               
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getFileName(self, **kwargs):
        """
        Specifies the base file name for the cache files. If more than one object is being cached and the format is OneFilePerFrame, each cache file will be prefixed with this base file name. In query mode, returns the files associated with the specified cacheFile node. When used with rpf/replaceCachedFrame or apf/appendFrame specifies the name of the backup files. If not specified, replaced frames will be stored with a default name. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        A query flag which returns the geometry controlled by the specified cache node                             
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getPointCount(self, **kwargs):
        """
        A query flag which returns the number of points stored in the cache file. The channelName flag should be used to specify the channel to be queried.                                
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getRunupFrames(self, **kwargs):
        """
        Specifies the number of frames of runup to simulate ahead of the starting frame. The value must be greater than or equal to 0.  The default is 2.                                  
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getSampleMultiplier(self, **kwargs):
        """
        Specifies the sample rate when caches are being created as a multiple of simulation Rate. If the value is 1, then a sample will be cached everytime the time is advanced.  If the value is 2, then every other sample will be cached, and so on.  The default is 1.                                
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getSimulationRate(self, **kwargs):
        """
        Specifies the simulation rate when caches are being created.  During cache creation, the time will be advanced by the simulation rate, until the end time of the cache is reached or surpassed.  The value is given in frames. The default value is 1 frame.                               
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def getStaticCache(self, **kwargs):
        """
        If false, during cache creation, do not save a cache for the object if it appears to have no animation or deformation. If true, save a cache even if the object appears to have no animation or deformation. Default is true. In query mode, when supplied a shape, the flag returns true if the shape appears to have no animation or deformation.                                
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def replaceWithoutSimulating(self, val='True', **kwargs):
        """
        When replacing cached frames, this flag specifies whether the replacement should come from the cached node without simulating or from advancing time and letting the simulation run.  This flag is valid only when neither the startTime nor endTime flags are used or when both the startTime and endTime flags specify the same time value.                              
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def setRunupFrames(self, val='True', **kwargs):
        """
        Specifies the number of frames of runup to simulate ahead of the starting frame. The value must be greater than or equal to 0.  The default is 2.                                  
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def setSampleMultiplier(self, val='True', **kwargs):
        """
        Specifies the sample rate when caches are being created as a multiple of simulation Rate. If the value is 1, then a sample will be cached everytime the time is advanced.  If the value is 2, then every other sample will be cached, and so on.  The default is 1.                                
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    def setSimulationRate(self, val='True', **kwargs):
        """
        Specifies the simulation rate when caches are being created.  During cache creation, the time will be advanced by the simulation rate, until the end time of the cache is reached or surpassed.  The value is given in frames. The default value is 1 frame.                               
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Creates one or more cache files on disk to store attribute data for a span of
        frames. The caches can be created for points/normals on a geometry (using the
        pts/points or pan/pointsAndNormals flag), for vectorArray output data (using the
        oa/outAttr flag), or for additional node specific data (using the
        cnd/cacheableNode flag for those nodes that support it). When the ia/inAttr flag
        is used, connects a cacheFile node that associates the data file on disk with
        the attribute. Frames can be replaced/appended to an existing cache with the
        rcf/replaceCachedFrame and apf/appendFrame flag.  Replaced frames are never
        deleted. They are stored in the same directory as the original cache files with
        the name provided by the f/fileName flag. If no file name is provided, the
        cacheFile name is prefixed with backupfollowed by a unique number. Single file
        caches are backed up in their entirety. To revert to an older version, simply
        attach to this cache. One file per frame caches only backup the description file
        and the frames that were replaced. To recover these types of caches, the user
        must rename these files to the original name.
        
        Flags:
        - appendFrame : apf              (bool)          [create]
            Appends data to the cache for the times specified by the startTime and endTime
            flags. If no time is provided, appends the current time. Must be used in
            conjunction with the pts/points or cnd/cacheableNode flag. Any overwritten
            frames will not be deleted, but renamed as specified by the f/fileName flag.
        
        - attachFile : af                (bool)          [create]
            Used to indicate that rather than creating a cache file, that an existing cache
            file on disk should be attached to an attribute in the scene. The inAttr flag is
            used to specify the attribute.
        
        - cacheFileNode : cfn            (unicode)       [create]
            Specifies the name of the cache file node(s) we are appending/replacing to if
            more than one cache is attached to the specified geometries.
        
        - cacheFormat : cf               (unicode)       [create,query]
            Cache file format, default is Maya's .mcx format, but others available via
            plugin
        
        - cacheInfo : ci                 (unicode)       [create,query]
            In create mode, used to specify a mel script returning a string array. When
            creating the cache, this mel script will be executed and the returned strings
            will be written to the .xml description file of the cache. In query mode,
            returns descriptive info stored in the cacheFile such as the user name, Maya
            scene name and maya version number.
        
        - cacheableAttrs : cat           (unicode)       [query]
            Returns the list of cacheable attributes defined on the accompanying cache node.
            This argument requires the use of the cacheableNode flag.
        
        - cacheableNode : cnd            (unicode)       [create]
            Specifies the name of a cacheable node whose contents will be cached. A
            cacheable node is a node that is specially designed to work with the caching
            mechanism.  An example of a cacheable node is a nCloth node.
        
        - channelIndex : chi             (bool)          [create,query]
            A query-only flag which returns the channel index for the selected geometry for
            the cacheFile node specified using the cacheFileNode flag.
        
        - channelName : cnm              (unicode)       [create,query]
            When attachFile is used, used to indicate the channel in the file that should be
            attached to inAttr.  If not specified, the first channel in the file is used. In
            query mode, allows user to query the channels associated with a description
            file.
        
        - convertPc2 : pc2               (bool)          [create]
            Convert a PC2 file to the Maya cache format (true), or convert Maya cache to pc2
            format (false)
        
        - createCacheNode : ccn          (bool)          [create]
            Used to indicate that rather than creating a cache file, that a cacheFile node
            should be created related to an existing cache file on disk.
        
        - creationChannelName : cch      (unicode)       [create]
            When creating a new cache, this multi-use flag specifies the channels to be
            cached. The names come from the cacheable channel names defined by the object
            being cached. If this flag is not used when creating a cache, then all cacheable
            channels are cached.
        
        - dataSize : dsz                 (bool)          [query]
            This is a query-only flag that returns the size of the data being cached per
            frame. This flag is to be used in conjunction with the cacheableNode, points,
            pointsAndNormals and outAttr flags.
        
        - deleteCachedFrame : dcf        (bool)          [create]
            Deletes cached data for the times specified by the startTime/endTime flags. If
            no time is provided, deletes the current frame. Must be used in conjunction with
            the pts/points or cnd/cacheableNode flag. Deleted frames will not be removed
            from disk, but renamed as specified by the f/fileName flag.
        
        - descriptionFileName : dfn      (bool)          [query]
            This is a query-only flag that returns the name of the description file for an
            existing cacheFile node. Or if no cacheFile node is specified, it returns the
            description file name that would be created based on the other flags specified.
        
        - directory : dir                (unicode)       [create,query]
            Specifies the directory where the cache files will be located. If the directory
            flag is not specified, the cache files will be placed in the project data
            directory.
        
        - doubleToFloat : dtf            (bool)          [create]
            During cache creation, double data is stored in the file as floats.  This helps
            cut down file size.
        
        - endTime : et                   (time)          [create]
            Specifies the end frame of the cache range.
        
        - fileName : f                   (unicode)       [create,query]
            Specifies the base file name for the cache files. If more than one object is
            being cached and the format is OneFilePerFrame, each cache file will be prefixed
            with this base file name. In query mode, returns the files associated with the
            specified cacheFile node. When used with rpf/replaceCachedFrame or
            apf/appendFrame specifies the name of the backup files. If not specified,
            replaced frames will be stored with a default name. In query mode, this flag can
            accept a value.
        
        - format : fm                    (unicode)       [create]
            Specifies the distribution format of the cache.  Valid values are OneFileand
            OneFilePerFrame
        
        - geometry : gm                  (bool)          [query]
            A query flag which returns the geometry controlled by the specified cache node
        
        - inAttr : ia                    (unicode)       [create]
            Specifies the name of the attribute that the cache file will drive. This file is
            optional when creating cache files. If this flag is not used during create mode,
            the cache files will be created on disk, but will not be driving anything in the
            scene. This flag is required when the attachFile flag is used.
        
        - inTangent : it                 (unicode)       [create]
            Specifies the in-tangent type when interpolating frames before the replaced
            frame(s). Must be used with the ist/interpStartTime and iet/interpEndTime flags.
            Valid values are linear, smoothand step.
        
        - interpEndTime : iet            (time)          [create]
            Specifies the frame until which there will be linear interpolation, beginning at
            endTime. Must be used with the rpf/replaceCachedFrame or apf/appendFrame flag.
            Interpolation is achieved by removing frames between endTime and interpEndTime
            from the cache. Removed frames will be renamed as specified by the f/fileName
            flag.
        
        - interpStartTime : ist          (time)          [create]
            Specifies the frame from which to begin linear interpolation, ending at
            startTime. Must be used with the rpf/replaceCachedFrame or apf/appendFrame
            flags. Interpolation is achieved by removing  frames between interpStartTime and
            startTime from the cache. These removed frames will will be renamed as specified
            by the f/fileName flag.
        
        - noBackup : nb                  (bool)          [create]
            Specifies that backup files should not be created for any files that may be
            over-written during append, replace or delete cache frames. Can only be used
            with the apf/appendFrame, rpf/replaceCachedFrame or dcf/deleteCachedFrame flags.
        
        - outAttr : oa                   (unicode)       [create]
            Specifies the name of the attribute that will be cached to disk.
        
        - outTangent : ot                (unicode)       [create]
            Specifies the out-tangent type when interpolating frames after the replaced
            frame(s). Must be used with the ist/interpStartTime and iet/interpEndTime flags.
            Valid values are linear, smoothand step.
        
        - pc2File : pcf                  (unicode)       [create]
            Specifies the full path to the pc2 file.  Must be used in conjunction with the
            pc2 flag.
        
        - pointCount : pc                (bool)          [query]
            A query flag which returns the number of points stored in the cache file. The
            channelName flag should be used to specify the channel to be queried.
        
        - points : pts                   (unicode)       [create]
            Specifies the name of a geometry whose points will be cached.
        
        - pointsAndNormals : pan         (unicode)       [create]
            Specifies the name of a geometry whose points and normals will be cached. The
            normals is per-vertex per-polygon. The normals cache cannot be imported back to
            geometry. This flag can only be used to export cache file. It cannot be used
            with the apf/appendFrame, dcf/deleteCachedFrame and rpf/replaceCachedFrame
            flags.
        
        - prefix : p                     (bool)          [create]
            Indicates that the specified fileName should be used as a prefix for the
            cacheName.
        
        - refresh : r                    (bool)          [create]
            When used during cache creation, forces a screen refresh during caching. This
            causes the cache creation to be slower but allows you to see how the simulation
            is progressing during the cache.
        
        - replaceCachedFrame : rcf       (bool)          [create]
            Replaces cached data for the times specified by the startTime/endTime flags. If
            no time is provided, replaces cache file for the current time. Must be used in
            conjunction with the pts/points or cnd/cacheableNode flag. Replaced frames will
            not be deleted, but renamed as specified by the f/fileName flag.
        
        - replaceWithoutSimulating : rws (bool)          [edit]
            When replacing cached frames, this flag specifies whether the replacement should
            come from the cached node without simulating or from advancing time and letting
            the simulation run.  This flag is valid only when neither the startTime nor
            endTime flags are used or when both the startTime and endTime flags specify the
            same time value.
        
        - runupFrames : rf               (int)           [create,query,edit]
            Specifies the number of frames of runup to simulate ahead of the starting frame.
            The value must be greater than or equal to 0.  The default is 2.
        
        - sampleMultiplier : spm         (int)           [create,query,edit]
            Specifies the sample rate when caches are being created as a multiple of
            simulation Rate. If the value is 1, then a sample will be cached everytime the
            time is advanced.  If the value is 2, then every other sample will be cached,
            and so on.  The default is 1.
        
        - simulationRate : smr           (time)          [create,query,edit]
            Specifies the simulation rate when caches are being created.  During cache
            creation, the time will be advanced by the simulation rate, until the end time
            of the cache is reached or surpassed.  The value is given in frames. The default
            value is 1 frame.
        
        - singleCache : sch              (bool)          [create]
            When used in conjunction with the points, pointsAndNormal or cacheableNode flag,
            specifies whether multiple geometries should be put into a single cache or to
            create one cache per geometry (default).
        
        - startTime : st                 (time)          [create]
            Specifies the start frame of the cache range.
        
        - staticCache : sc               (bool)          [create,query]
            If false, during cache creation, do not save a cache for the object if it
            appears to have no animation or deformation. If true, save a cache even if the
            object appears to have no animation or deformation. Default is true. In query
            mode, when supplied a shape, the flag returns true if the shape appears to have
            no animation or deformation.
        
        - worldSpace : ws                (bool)          [create]
            If the points flag is used, turning on this flag will result in the world space
            positions of the points being written. The expected use of this flag is for
            cache export.                                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.cacheFile`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Unfold3DOptimize(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OffsetCos(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Repro(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class JointLattice(GeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getCreasing(self, **kwargs):
        """
        Affects the bulging of lattice points on the inside of the bend.  Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getLengthIn(self, **kwargs):
        """
        Affects the location of lattice points on the parent bone.  Positive/negative values cause the points to move away/towards the joint. Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getLengthOut(self, **kwargs):
        """
        Affects the location of lattice points on the child bone. Positive/negative values cause the points to move away/towards the joint. Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getRounding(self, **kwargs):
        """
        Affects the bulging of lattice points on the outside of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getWidthLeft(self, **kwargs):
        """
        Affects the bulging of lattice points on the left side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def getWidthRight(self, **kwargs):
        """
        Affects the bulging of lattice points on the right side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def setCreasing(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the inside of the bend.  Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def setLengthIn(self, val='True', **kwargs):
        """
        Affects the location of lattice points on the parent bone.  Positive/negative values cause the points to move away/towards the joint. Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def setLengthOut(self, val='True', **kwargs):
        """
        Affects the location of lattice points on the child bone. Positive/negative values cause the points to move away/towards the joint. Changing this parameter also modifies the regions affected by the creasing, rounding and width parameters. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def setRounding(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the outside of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def setWidthLeft(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the left side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    def setWidthRight(self, val='True', **kwargs):
        """
        Affects the bulging of lattice points on the right side of the bend. Positive/negative values cause the points to bulge outwards/inwards. Default value is 0.0. When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a jointLattice deformer. The name of the
        created/edited object is returned. Usually you would make use of this
        functionality through the higher level flexor command.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - creasing : cr                  (float)         [create,query,edit]
            Affects the bulging of lattice points on the inside of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - joint : j                      (unicode)       [create]
            Specifies the joint which will be used to drive the bulging behaviours.
        
        - lengthIn : li                  (float)         [create,query,edit]
            Affects the location of lattice points on the parent bone.  Positive/negative
            values cause the points to move away/towards the joint. Changing this parameter
            also modifies the regions affected by the creasing, rounding and width
            parameters. Default value is 0.0. When queried, this flag returns a float.
        
        - lengthOut : lo                 (float)         [create,query,edit]
            Affects the location of lattice points on the child bone. Positive/negative
            values cause the points to move away/towards the joint. Changing this parameter
            also modifies the regions affected by the creasing, rounding and width
            parameters. Default value is 0.0. When queried, this flag returns a float.
        
        - lowerBindSkin : lb             (unicode)       [create]
            Specifies the node which is performing the bind skin operation on the geometry
            associated with the lower bone.
        
        - lowerTransform : lt            (unicode)       [create]
            Specifies which dag node is being used to rigidly transform the lower part of
            the lattice which this node is going to deform. If this flag is not specified an
            identity matrix will be assumed.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - rounding : ro                  (float)         [create,query,edit]
            Affects the bulging of lattice points on the outside of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - upperBindSkin : ub             (unicode)       [create]
            Specifies the node which is performing the bind skin operation on the geometry
            associated with the upper bone.
        
        - upperTransform : ut            (unicode)       [create]
            Specifies which dag node is being used to rigidly transform the upper part of
            the lattice which this node is going to deform. If this flag is not specified an
            identity matrix will be assumed.
        
        - widthLeft : wl                 (float)         [create,query,edit]
            Affects the bulging of lattice points on the left side of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.
        
        - widthRight : wr                (float)         [create,query,edit]
            Affects the bulging of lattice points on the right side of the bend.
            Positive/negative values cause the points to bulge outwards/inwards. Default
            value is 0.0. When queried, this flag returns a float.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.jointLattice`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TrimWithBoundaries(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class CreatePtexUV(THdependNode):
    """
    class counterpart of mel function `createPtexUV`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - bleed : bl                     (int)           []
        
        - inMesh : im                    (unicode)       []
        
        - tileCount : tc                 (int)           []
        
        
        Derived from mel command `maya.cmds.createPtexUV`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiWriteRgba(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Loft(AbstractBaseCreate):
    def getAutoReverse(self, **kwargs):
        """
        If set to true, the direction of the curves for the loft is computed automatically.  If set to false, the values of the multi-use reverse flag are used instead. Default:true                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getClose(self, **kwargs):
        """
        If set to true, the resulting surface will be closed (periodic) with the start (end) at the first curve.  If set to false, the surface will remain open. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getCreateCusp(self, **kwargs):
        """
        Multi-use flag; each occurence of the flag refers to the matching curve in the loft operation; if the flag is set the particular profile will have a cusp (tangent break) in the resulting surface. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface Default:3                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getReverse(self, **kwargs):
        """
        Multi-use flag; each occurence of the flag refers to the matching curve in the loft operation; if the flag is set the particular curve will be reversed before being used in the loft operation. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getReverseSurfaceNormals(self, **kwargs):
        """
        If set, the surface normals on the output NURBS surface will be reversed.  This is accomplished by swapping the U and V parametric directions. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getSectionSpans(self, **kwargs):
        """
        The number of surface spans between consecutive curves in the loft. Default:1                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def getUniform(self, **kwargs):
        """
        If set to true, the resulting surface will have uniform parameterization in the loft direction.  If set to false, the parameterization will be chord length. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setAutoReverse(self, val='True', **kwargs):
        """
        If set to true, the direction of the curves for the loft is computed automatically.  If set to false, the values of the multi-use reverse flag are used instead. Default:true                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setClose(self, val='True', **kwargs):
        """
        If set to true, the resulting surface will be closed (periodic) with the start (end) at the first curve.  If set to false, the surface will remain open. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setCreateCusp(self, val='True', **kwargs):
        """
        Multi-use flag; each occurence of the flag refers to the matching curve in the loft operation; if the flag is set the particular profile will have a cusp (tangent break) in the resulting surface. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface Default:3                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setReverse(self, val='True', **kwargs):
        """
        Multi-use flag; each occurence of the flag refers to the matching curve in the loft operation; if the flag is set the particular curve will be reversed before being used in the loft operation. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setReverseSurfaceNormals(self, val='True', **kwargs):
        """
        If set, the surface normals on the output NURBS surface will be reversed.  This is accomplished by swapping the U and V parametric directions. Default:false                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setSectionSpans(self, val='True', **kwargs):
        """
        The number of surface spans between consecutive curves in the loft. Default:1                  
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    def setUniform(self, val='True', **kwargs):
        """
        If set to true, the resulting surface will have uniform parameterization in the loft direction.  If set to false, the parameterization will be chord length. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command computes a skinned (lofted) surface passing through a number of
        NURBS curves. There must be at least two curves present. The NURBS curves may be
        surface isoparms, curve on surfaces, trimmed edges or polygon edges.
        
        Flags:
        - autoReverse : ar               (bool)          [create,query,edit]
            If set to true, the direction of the curves for the loft is computed
            automatically.  If set to false, the values of the multi-use reverse flag are
            used instead. Default:true
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - close : c                      (bool)          [create,query,edit]
            If set to true, the resulting surface will be closed (periodic) with the start
            (end) at the first curve.  If set to false, the surface will remain open.
            Default:false
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - createCusp : cc                (bool)          [create,query,edit]
            Multi-use flag; each occurence of the flag refers to the matching curve in the
            loft operation; if the flag is set the particular profile will have a cusp
            (tangent break) in the resulting surface. Default:false
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface Default:3
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.
        
        - rebuild : rb                   (bool)          [create]
            Rebuild the input curve(s) before using them in the operation.  Use
            nurbsCurveRebuildPref to set the parameters for the conversion.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        - reverse : r                    (bool)          [create,query,edit]
            Multi-use flag; each occurence of the flag refers to the matching curve in the
            loft operation; if the flag is set the particular curve will be reversed before
            being used in the loft operation. Default:false
        
        - reverseSurfaceNormals : rsn    (bool)          [create,query,edit]
            If set, the surface normals on the output NURBS surface will be reversed.  This
            is accomplished by swapping the U and V parametric directions. Default:false
        
        - sectionSpans : ss              (int)           [create,query,edit]
            The number of surface spans between consecutive curves in the loft. Default:1
        
        - uniform : u                    (bool)          [create,query,edit]
            If set to true, the resulting surface will have uniform parameterization in the
            loft direction.  If set to false, the parameterization will be chord length.
            Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.loft`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ClientDevice(ThreadedDevice):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimBlendNodeAdditiveRotation(AnimBlendNodeBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiColorJitter(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ResultCurve(AnimCurve):
    __melnode__ = []
    
    
    __readonly__ = {}


class ReverseSurface(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.reverseSurface`
        """
        pass
    def getDirection(self, **kwargs):
        """
        The direction to reverse the surface in: 0 - U, 1 - V, 2 - Both U and V, 3 - Swap Default:0                  
        
        
        Derived from mel command `maya.cmds.reverseSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.reverseSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.reverseSurface`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        The direction to reverse the surface in: 0 - U, 1 - V, 2 - Both U and V, 3 - Swap Default:0                  
        
        
        Derived from mel command `maya.cmds.reverseSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.reverseSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The reverseSurface command reverses one or both directions of a surface or can
        be used to swapthe U and V directions (this creates the effect of reversing the
        surface normal). The name of the newly reversed surface and the name of the
        resulting dependency node is returned. The resulting surface has the same
        parameter ranges as the original surface. This command also handles selected
        surface isoparms. For a selected isoparm, imagine that the isoparm curve is
        reversed after the operation. E.g. reverseSurface surface.v[0.1] will reverse in
        the U direction.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - direction : d                  (int)           [create,query,edit]
            The direction to reverse the surface in: 0 - U, 1 - V, 2 - Both U and V, 3 -
            Swap Default:0
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - noChanges : nc                 (bool)          []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.reverseSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSwitchOperator(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiFlakes(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStandard(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKState2Effector(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ProjectCurve(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def getDirection(self, **kwargs):
        """
        Direction of projection. Available only if useNormal is false.                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        X direction of projection. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        Y direction of projection. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        Z direction of projection. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        Tolerance to fit to. Default:0.01                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def getUseNormal(self, **kwargs):
        """
        True if the surface normal is to be used and false if the direction vector should be used instead. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        Direction of projection. Available only if useNormal is false.                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        X direction of projection. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        Y direction of projection. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        Z direction of projection. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        Tolerance to fit to. Default:0.01                  
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    def setUseNormal(self, val='True', **kwargs):
        """
        True if the surface normal is to be used and false if the direction vector should be used instead. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The projectCurve command creates curves on surface where all selected curves
        project onto the selected surfaces. Projection can be done using the surface
        normals or the user can specify the vector to project along. Note: the user does
        not have to specify the curves and surfaces in any particular order in the
        command line.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - direction : d                  (float, float, float) [create,query,edit]
            Direction of projection. Available only if useNormal is false.
        
        - directionX : dx                (float)         [create,query,edit]
            X direction of projection. Default:0.0
        
        - directionY : dy                (float)         [create,query,edit]
            Y direction of projection. Default:0.0
        
        - directionZ : dz                (float)         [create,query,edit]
            Z direction of projection. Default:1.0
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - tolerance : tol                (float)         [create,query,edit]
            Tolerance to fit to. Default:0.01
        
        - useNormal : un                 (bool)          [create,query,edit]
            True if the surface normal is to be used and false if the direction vector
            should be used instead. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.projectCurve`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class IkMCsolver(IkSolver):
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierBase(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiFraction(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TimeEditorClip(TimeEditorClipBase):
    def addClipAttribute(self, val='True', **kwargs):
        """
        Add new attribute to the clip.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def allowShrinking(self, val='True', **kwargs):
        """
        When extending clip, allow shrinking.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def clipId(self, val='True', **kwargs):
        """
        ID of the clip to be edited.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def copyClip(self, val='True', **kwargs):
        """
        Get the selected clip IDs and store them in a list that could be used for pasting.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def duplicateClip(self, val='True', **kwargs):
        """
        Duplicate clip into two clips with the same timing info.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def exclusive(self, val='True', **kwargs):
        """
        Populate all types of animation sources which are not listed by typeFlag.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def existingOnly(self, val='True', **kwargs):
        """
        This flag can only be used in edit mode, in conjunction with the animSource flag. Retain the animSource flag functionality but only bind attributes that are already part of the clip. It does not attempt to populate unbound source attributes to their default destination.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def explode(self, val='True', **kwargs):
        """
        Reparent all tracks and their clips within a group out to its parent track node and remove the group.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def exportAllClips(self, val='True', **kwargs):
        """
        When used with the ef/exportFbxflag, export all clips.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def exportFbx(self, val='True', **kwargs):
        """
        Export currently selected clips to FBX files.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def extend(self, val='True', **kwargs):
        """
        Extend the clip to encompass all children.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def extendParent(self, val='True', **kwargs):
        """
        Extend parent to fit this clip.                                    
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getAbsolute(self, **kwargs):
        """
        This flag is used in conjunction with other timing flags like -s/start, -d/duration, -ed/end, etc. to query (global) absolute time.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getAddObjects(self, **kwargs):
        """
        Populate the given object(s) and their attributes to anim source to Time Editor. For multiple object, pass each name separated by semicolon. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames for the given object(s). Similar to -addSelectedObjectsflag but acts on given object(s) instead. This flag will override the flag -addSelectedObjects.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getAddRelatedKG(self, **kwargs):
        """
        During population, determine if associated keying groups should be populated or not. Normally used for populating HIK. By default the value is false.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getAddSelectedObjects(self, **kwargs):
        """
        Populate the currently selected objects and their attributes to anim source or Time Editor. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getAnimSource(self, **kwargs):
        """
        Populate based on animation source.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getChildren(self, **kwargs):
        """
        Get children clip IDs.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getClipAfter(self, **kwargs):
        """
        Get the clip ID of the next clip.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getClipBefore(self, **kwargs):
        """
        Get the clip ID of the previous clip.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getClipDataType(self, **kwargs):
        """
        Query the type of data being driven by the given clip ID. Return values are: 0 : Animation       - Clip drives animation curves1 : Audio           - Clip drives audio3 : Group           - Clip is a group
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getClipIdFromNodeName(self, **kwargs):
        """
        Get clip ID from clip node name.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getClipIdFromPath(self, **kwargs):
        """
        Flag for querying the clip ID given the path. Clip path is a vertical-bar-delimited string to indicate a hierarchical structure of a clip. Please refer to the hierarchical path in outliner to see how it is represented. For example: composition1|track1|clip1 Note: To specify the path, this flag must appear before -query flag.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getClipNode(self, **kwargs):
        """
        Flag for querying the name of the clip node.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getClipPath(self, **kwargs):
        """
        Flag for querying the path given the clip ID. Clip path is a vertical bar delimited string to indicate a hierarchical structure of a clip. Please refer to the hierarchical path in outliner to see how it is represented. For example: composition1|track1|clip1. Note: If the clip is not connected to any track, it will return empty string.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getCrossfadeMode(self, **kwargs):
        """
        Set the crossfading mode between two clips that lie on the same track, and that are specified with the -clipId flags: 0 : linear          - Two clips are blended with a constant ratio1 : step            - Left clip keeps its value until the middle of the crossfading region and then right clip's value is used2 : hold left       - Use only left clip's value3 : hold right      - Use only right clip's value4 : custom          - User defined crossfade curve5 : custom (spline) - User defined crossfade curve with spline preset
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getCrossfadePlug(self, **kwargs):
        """
        Get plug path for a custom crossfade curve between 2 clips.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getCurveTime(self, **kwargs):
        """
        Query the curve local time in relation to the given clip.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getDefaultGhostRoot(self, **kwargs):
        """
        Edit or query default ghost root variable. Determine whether to use the default ghost root (object driven by clip).                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getDrivenAttributes(self, **kwargs):
        """
        Return a list of attributes driven by a clip.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getDrivenClipsBySource(self, **kwargs):
        """
        Returns the clips driven by the given source. Can filter the return result by the specified type, like animCurve, expression, constraint, etc. This flag must come before the -query flag.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getDrivenObjects(self, **kwargs):
        """
        Return an array of strings consisting of the names of all objects driven by the current clip and its children clips.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getDrivenRootObjects(self, **kwargs):
        """
        Return an array of strings consisting of the names of all root objects driven by this clip and its children clips.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getDrivingSources(self, **kwargs):
        """
        Return all sources driving the given clip. Can filter the return result by the specified type, like animCurve, expression, constraint, etc. If used after the -query flag (without an argument), the command returns all sources driving the given clip. To specify the type, this flag must appear before the -query flag. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getDuration(self, **kwargs):
        """
        Relative duration of the new clip.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getEndTime(self, **kwargs):
        """
        Query the relative end time of the clip.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getExists(self, **kwargs):
        """
        Return true if the specified clip exists.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getGhost(self, **kwargs):
        """
        Enable/disable ghosting for the specified clip.                                    
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getHoldEnd(self, **kwargs):
        """
        Hold clip's end to time.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getHoldStart(self, **kwargs):
        """
        Hold clip's start to time.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getIsContainer(self, **kwargs):
        """
        Indicate if given clip ID is a container.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getListUserGhostRoot(self, **kwargs):
        """
        Get user defined ghost root object for indicated clips.                                    
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getLoopEnd(self, **kwargs):
        """
        Loop clip's end to time.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getLoopStart(self, **kwargs):
        """
        Loop clip's start to time.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getMinClipDuration(self, **kwargs):
        """
        Returns the minimum allowed clip duration.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getMute(self, **kwargs):
        """
        Mute/Unmute the clip given a clip ID. In query mode, return the muted state of the clip. Clips muted by soloing are not affected by this flag.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getParentClipId(self, **kwargs):
        """
        Specify the parent clip ID of a clip to be created.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getParentGroupId(self, **kwargs):
        """
        Return the parent group ID of the given clip.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getRemappedSourceAttrs(self, **kwargs):
        """
        Return an array of attribute indices and names of the source attributes of a remapped clip.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getRemappedTargetAttrs(self, **kwargs):
        """
        Return an array of attribute indices and names of the target attributes of a remapped clip.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getRemoveWeightCurve(self, **kwargs):
        """
        Remove the weight curve connected to the clip.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getSpeedRamping(self, **kwargs):
        """
        To control the playback speed of the clip by animation curve: 1 : create - Attach a speed curve and a time warp curve to the clip to control the playback speed2 : edit - Open the Graph editor to edit the speed curve3 : enable - Create a time warp curve from current speed curve and attach to clip4 : disable - Remove the time warp curve from clip5 : delete - Delete the attached speed curve and time warp curve6 : reset - Reset the speed curve back to the default7 : convert to speed curve from time warp8 : convert to time warp from speed curveIn query mode, return true if a speed curve is attached to the clip.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getStartTime(self, **kwargs):
        """
        Relative start time of the new clip.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getTimeWarp(self, **kwargs):
        """
        Return true if the clip is being warped by the speed curve. If no speed curve is attached to the clip, it will always return false.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getTimeWarpCurve(self, **kwargs):
        """
        Returns the name of the time warp curve connected to the clip.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getTimeWarpType(self, **kwargs):
        """
        Time warp mode: 0: remapping - Connected time warp curve performs frame by frame remapping1: speed curve - Connected time warp curve acts as a speed curveIn query mode, return time warp mode of a clip.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getTrack(self, **kwargs):
        """
        The new clip container will be created on the track in the format trackNode:trackNumber, or on a track path, for example composition1|track1. In query mode, return a string containing the track number and tracks node of the given clip ID. In create mode, if the track number is '-1' or not given at all, then a new track will be created. For example: trackNode:-1; composition1|.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getTracksNode(self, **kwargs):
        """
        Get tracks node if specified clip is a group clip.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getTruncated(self, **kwargs):
        """
        This flag is used in conjunction with other timing flags like -s/start, -d/duration, -ed/end, etc. to query (global) truncated time.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getType(self, **kwargs):
        """
        Only populate the specified type of animation source.                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getUserGhostRoot(self, **kwargs):
        """
        Edit or query custom ghost root variable. Determine whether to use user defined ghost root.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def getWeightCurve(self, **kwargs):
        """
        In edit mode, create a weight curve and connect it to the clip. In query mode, return the name of the weight curve connected to the clip.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def ghostRootAdd(self, val='True', **kwargs):
        """
        Add path to specified node as a custom ghost root.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def ghostRootRemove(self, val='True', **kwargs):
        """
        Remove path to specified node as a custom ghost root.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def importOption(self, val='True', **kwargs):
        """
        Option for importing animation source. Specify either 'connect' or 'generate'. connect:  Only connect with nodes already existing in the scene.                   Importing an animation source that does not match with any element                   of the current scene will not create any clip.                   (connect is the default mode). generate: Import everything and generate new nodes for items not existing in the scene.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def importPopulateOption(self, val='True', **kwargs):
        """
        Option for population when importing.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def includeRoot(self, val='True', **kwargs):
        """
        Populate transform (Translate, Rotate, Scale) of hierarchy root nodes.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def modifyAnimSource(self, val='True', **kwargs):
        """
        When populating, automatically modify Anim Source without asking the user.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def moveClip(self, val='True', **kwargs):
        """
        Move clip by adding delta to its start time.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def parent(self, val='True', **kwargs):
        """
        Specify group/object parent ID.                                    
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def pasteClip(self, val='True', **kwargs):
        """
        Paste clip to the given time and track. Destination track is required to be specified through the track flag in the format tracksNode:trackIndex. A trackIndex of -1 indicates that a new track will be created.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def path(self, val='True', **kwargs):
        """
        Full path of the clip to be edited. For example: composition1|track1|clip1. In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def populateAttribute(self, val='True', **kwargs):
        """
        Populate a specific attribute on a object.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def razorClip(self, val='True', **kwargs):
        """
        Razor clip into two clips at the specified time.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def recursively(self, val='True', **kwargs):
        """
        Populate selection recursively, adding all the children.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def remap(self, val='True', **kwargs):
        """
        Change animation source for a given clip item to a new one, specified by the target path. This removes all clips for the roster item and creates new clips from the Anim Source for the new target path.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def remapSource(self, val='True', **kwargs):
        """
        Set animation source to be remapped for a given clip item to new one, specified by the target path.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def removeClip(self, val='True', **kwargs):
        """
        Remove clip of specified ID.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def removeClipAttribute(self, val='True', **kwargs):
        """
        Remove attribute from the clip.                                    
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def removeCrossfade(self, val='True', **kwargs):
        """
        Remove custom crossfade between two clips specified by -clipId flags.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def removeSceneAnimation(self, val='True', **kwargs):
        """
        If true, remove animation from scene when creating clips or anim sources. Only Time Editor will drive the removed scene animation.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def resetTiming(self, val='True', **kwargs):
        """
        Reset start and duration of a clip with the given clip ID to the values stored in its Anim Source.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def resetTransition(self, val='True', **kwargs):
        """
        Reset transition intervals between specified clips.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def ripple(self, val='True', **kwargs):
        """
        Apply rippling to a clip operation.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def rootClipId(self, val='True', **kwargs):
        """
        ID of the root clip. It is used together with various clip editing flags. When used, the effect of clip editing and its parameters will be affected by the given root clip. For example, moving a clip under the group root (usually in group tab view) will be performed in the local time space of the group root.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def rootPath(self, val='True', **kwargs):
        """
        Path of the root clip. It is used together with various clip editing flags. When used, the effect of clip editing and its parameters will be affected by the given root clip. For example, moving a clip under the group root (usually in group tab view) will be performed in the local time space of the group root.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def scaleEnd(self, val='True', **kwargs):
        """
        Scale the end time of the clip to the given time.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def scalePivot(self, val='True', **kwargs):
        """
        Scale the time of the clip based on the pivot. This should be used together with -scs/scaleStartor -sce/scaleEnd.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def scaleStart(self, val='True', **kwargs):
        """
        Scale the start time of the clip to the given time.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setAddObjects(self, val='True', **kwargs):
        """
        Populate the given object(s) and their attributes to anim source to Time Editor. For multiple object, pass each name separated by semicolon. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames for the given object(s). Similar to -addSelectedObjectsflag but acts on given object(s) instead. This flag will override the flag -addSelectedObjects.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setAddRelatedKG(self, val='True', **kwargs):
        """
        During population, determine if associated keying groups should be populated or not. Normally used for populating HIK. By default the value is false.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setAddSelectedObjects(self, val='True', **kwargs):
        """
        Populate the currently selected objects and their attributes to anim source or Time Editor. In query mode, return the number of attributes that will be populated given the flags, along with the animation's first and last frames.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setAnimSource(self, val='True', **kwargs):
        """
        Populate based on animation source.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setCrossfadeMode(self, val='True', **kwargs):
        """
        Set the crossfading mode between two clips that lie on the same track, and that are specified with the -clipId flags: 0 : linear          - Two clips are blended with a constant ratio1 : step            - Left clip keeps its value until the middle of the crossfading region and then right clip's value is used2 : hold left       - Use only left clip's value3 : hold right      - Use only right clip's value4 : custom          - User defined crossfade curve5 : custom (spline) - User defined crossfade curve with spline preset
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setDefaultGhostRoot(self, val='True', **kwargs):
        """
        Edit or query default ghost root variable. Determine whether to use the default ghost root (object driven by clip).                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setGhost(self, val='True', **kwargs):
        """
        Enable/disable ghosting for the specified clip.                                    
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setHoldEnd(self, val='True', **kwargs):
        """
        Hold clip's end to time.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setHoldStart(self, val='True', **kwargs):
        """
        Hold clip's start to time.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setKeyframe(self, val='True', **kwargs):
        """
        Set keyframe on a specific clip for a specified attribute.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setLoopEnd(self, val='True', **kwargs):
        """
        Loop clip's end to time.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setLoopStart(self, val='True', **kwargs):
        """
        Loop clip's start to time.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setMute(self, val='True', **kwargs):
        """
        Mute/Unmute the clip given a clip ID. In query mode, return the muted state of the clip. Clips muted by soloing are not affected by this flag.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setRemoveWeightCurve(self, val='True', **kwargs):
        """
        Remove the weight curve connected to the clip.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setSpeedRamping(self, val='True', **kwargs):
        """
        To control the playback speed of the clip by animation curve: 1 : create - Attach a speed curve and a time warp curve to the clip to control the playback speed2 : edit - Open the Graph editor to edit the speed curve3 : enable - Create a time warp curve from current speed curve and attach to clip4 : disable - Remove the time warp curve from clip5 : delete - Delete the attached speed curve and time warp curve6 : reset - Reset the speed curve back to the default7 : convert to speed curve from time warp8 : convert to time warp from speed curveIn query mode, return true if a speed curve is attached to the clip.                              
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setTimeWarpType(self, val='True', **kwargs):
        """
        Time warp mode: 0: remapping - Connected time warp curve performs frame by frame remapping1: speed curve - Connected time warp curve acts as a speed curveIn query mode, return time warp mode of a clip.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setTrack(self, val='True', **kwargs):
        """
        The new clip container will be created on the track in the format trackNode:trackNumber, or on a track path, for example composition1|track1. In query mode, return a string containing the track number and tracks node of the given clip ID. In create mode, if the track number is '-1' or not given at all, then a new track will be created. For example: trackNode:-1; composition1|.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setType(self, val='True', **kwargs):
        """
        Only populate the specified type of animation source.                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setUserGhostRoot(self, val='True', **kwargs):
        """
        Edit or query custom ghost root variable. Determine whether to use user defined ghost root.                                
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def setWeightCurve(self, val='True', **kwargs):
        """
        In edit mode, create a weight curve and connect it to the clip. In query mode, return the name of the weight curve connected to the clip.                                  
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def transition(self, val='True', **kwargs):
        """
        Create transition intervals between specified clips.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def trimEnd(self, val='True', **kwargs):
        """
        Trim the end time of the clip to the given time.                                   
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def trimStart(self, val='True', **kwargs):
        """
        Trim the start time of the clip to the given time.                                 
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def uniqueAnimSource(self, val='True', **kwargs):
        """
        If a given clip is sharing its Anim Source node with another clip, make the Anim Source of this clip unique.                               
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    def zeroKeying(self, val='True', **kwargs):
        """
        A toggle flag to use in conjunction with k/setKeyframe, set the value of the key frame(s) to be keyed to zero.                             
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command edits/queries Time Editor clips.
        
        Flags:
        - absolute : abs                 (bool)          [query]
            This flag is used in conjunction with other timing flags like -s/start,
            -d/duration, -ed/end, etc. to query (global) absolute time.
        
        - addAttribute : aa              (unicode)       [edit]
            Add new attribute to the clip.
        
        - addObjects : ao                (unicode)       [create,query,edit]
            Populate the given object(s) and their attributes to anim source to Time Editor.
            For multiple object, pass each name separated by semicolon. In query mode,
            return the number of attributes that will be populated given the flags, along
            with the animation's first and last frames for the given object(s). Similar to
            -addSelectedObjectsflag but acts on given object(s) instead. This flag will
            override the flag -addSelectedObjects.
        
        - addRelatedKG : akg             (bool)          [create,query,edit]
            During population, determine if associated keying groups should be populated or
            not. Normally used for populating HIK. By default the value is false.
        
        - addSelectedObjects : aso       (bool)          [create,query,edit]
            Populate the currently selected objects and their attributes to anim source or
            Time Editor. In query mode, return the number of attributes that will be
            populated given the flags, along with the animation's first and last frames.
        
        - allowShrinking : eas           (bool)          [edit]
            When extending clip, allow shrinking.
        
        - animSource : asr               (unicode)       [create,query,edit]
            Populate based on animation source.
        
        - attribute : at                 (unicode)       [create,edit]
            Populate a specific attribute on a object.
        
        - audio : au                     (unicode)       [create]
            Create a clip with audio inside.
        
        - children : chl                 (int)           [query]
            Get children clip IDs.
        
        - clipAfter : ca                 (bool)          [query]
            Get the clip ID of the next clip.
        
        - clipBefore : cb                (bool)          [query]
            Get the clip ID of the previous clip.
        
        - clipDataType : cdt             (bool)          [query]
            Query the type of data being driven by the given clip ID. Return values are: 0 :
            Animation       - Clip drives animation curves1 : Audio           - Clip drives
            audio3 : Group           - Clip is a group
        
        - clipId : id                    (int)           [create,edit]
            ID of the clip to be edited.
        
        - clipIdFromNodeName : idn       (int)           [query]
            Get clip ID from clip node name.
        
        - clipIdFromPath : idp           (bool)          [query]
            Flag for querying the clip ID given the path. Clip path is a vertical-bar-
            delimited string to indicate a hierarchical structure of a clip. Please refer to
            the hierarchical path in outliner to see how it is represented. For example:
            composition1|track1|clip1 Note: To specify the path, this flag must appear
            before -query flag.
        
        - clipNode : cln                 (bool)          [query]
            Flag for querying the name of the clip node.
        
        - clipPath : clp                 (bool)          [query]
            Flag for querying the path given the clip ID. Clip path is a vertical bar
            delimited string to indicate a hierarchical structure of a clip. Please refer to
            the hierarchical path in outliner to see how it is represented. For example:
            composition1|track1|clip1. Note: If the clip is not connected to any track, it
            will return empty string.
        
        - copyClip : ccl                 (bool)          [edit]
            Get the selected clip IDs and store them in a list that could be used for
            pasting.
        
        - crossfadeMode : cfm            (int)           [query,edit]
            Set the crossfading mode between two clips that lie on the same track, and that
            are specified with the -clipId flags: 0 : linear          - Two clips are
            blended with a constant ratio1 : step            - Left clip keeps its value
            until the middle of the crossfading region and then right clip's value is used2
            : hold left       - Use only left clip's value3 : hold right      - Use only
            right clip's value4 : custom          - User defined crossfade curve5 : custom
            (spline) - User defined crossfade curve with spline preset
        
        - crossfadePlug : cfp            (bool)          [query]
            Get plug path for a custom crossfade curve between 2 clips.
        
        - curveTime : cvt                (time)          [query]
            Query the curve local time in relation to the given clip.
        
        - defaultGhostRoot : dgr         (bool)          [query,edit]
            Edit or query default ghost root variable. Determine whether to use the default
            ghost root (object driven by clip).
        
        - drivenAttributes : dat         (bool)          [query]
            Return a list of attributes driven by a clip.
        
        - drivenClipsBySource : dcs      (unicode)       [query]
            Returns the clips driven by the given source. Can filter the return result by
            the specified type, like animCurve, expression, constraint, etc. This flag must
            come before the -query flag.
        
        - drivenObjects : dos            (bool)          [query]
            Return an array of strings consisting of the names of all objects driven by the
            current clip and its children clips.
        
        - drivenRootObjects : dro        (bool)          [query]
            Return an array of strings consisting of the names of all root objects driven by
            this clip and its children clips.
        
        - drivingSources : dsc           (unicode)       [query]
            Return all sources driving the given clip. Can filter the return result by the
            specified type, like animCurve, expression, constraint, etc. If used after the
            -query flag (without an argument), the command returns all sources driving the
            given clip. To specify the type, this flag must appear before the -query flag.
            In query mode, this flag can accept a value.
        
        - duplicateClip : dcl            (bool)          [edit]
            Duplicate clip into two clips with the same timing info.
        
        - duration : d                   (time)          [create,query]
            Relative duration of the new clip.
        
        - emptySource : ems              (bool)          [create]
            Create a clip with an empty source.
        
        - endTime : et                   (time)          [query]
            Query the relative end time of the clip.
        
        - exclusive : exc                (bool)          [create,edit]
            Populate all types of animation sources which are not listed by typeFlag.
        
        - existingOnly : exo             (bool)          [edit]
            This flag can only be used in edit mode, in conjunction with the animSource
            flag. Retain the animSource flag functionality but only bind attributes that are
            already part of the clip. It does not attempt to populate unbound source
            attributes to their default destination.
        
        - exists : exs                   (bool)          [query]
            Return true if the specified clip exists.
        
        - explode : epl                  (int)           [edit]
            Reparent all tracks and their clips within a group out to its parent track node
            and remove the group.
        
        - exportAllClips : eac           (bool)          [edit]
            When used with the ef/exportFbxflag, export all clips.
        
        - exportFbx : ef                 (unicode)       [edit]
            Export currently selected clips to FBX files.
        
        - extend : ex                    (bool)          [edit]
            Extend the clip to encompass all children.
        
        - extendParent : exp             (bool)          [edit]
            Extend parent to fit this clip.
        
        - ghost : gh                     (bool)          [query,edit]
            Enable/disable ghosting for the specified clip.
        
        - ghostRootAdd : gra             (unicode)       [edit]
            Add path to specified node as a custom ghost root.
        
        - ghostRootRemove : grr          (unicode)       [edit]
            Remove path to specified node as a custom ghost root.
        
        - group : grp                    (bool)          [create]
            Specify if the new container should be created as a group, containing other
            specified clips.
        
        - holdEnd : he                   (time)          [query,edit]
            Hold clip's end to time.
        
        - holdStart : hs                 (time)          [query,edit]
            Hold clip's start to time.
        
        - importAllFbxTakes : aft        (bool)          [create]
            Import all FBX takes into the new anim sources (for timeEditorAnimSource
            command) or new containers (for timeEditorClip command).
        
        - importFbx : fbx                (unicode)       [create]
            Import an animation from FBX file into the new anim source (for
            timeEditorAnimSource command) or new container (for timeEditorClip command).
        
        - importFbxTakes : ft            (unicode)       [create]
            Import multiple FBX takes (separated by semicolons) into the new anim sources
            (for timeEditorAnimSource command) or new containers (for timeEditorClip
            command).
        
        - importMayaFile : mf            (unicode)       [create]
            Import an animation from Maya file into the new anim sources (for
            timeEditorAnimSource command) or new containers (for timeEditorClip command).
        
        - importOption : io              (unicode)       [edit]
            Option for importing animation source. Specify either 'connect' or 'generate'.
            connect:  Only connect with nodes already existing in the scene.
            Importing an animation source that does not match with any element
            of the current scene will not create any clip.                   (connect is the
            default mode). generate: Import everything and generate new nodes for items not
            existing in the scene.
        
        - importPopulateOption : ipo     (unicode)       [edit]
            Option for population when importing.
        
        - importTakeDestination : itd    (int)           [create]
            Specify how to organize imported FBX takes: 0 - Import takes into a group
            (default) 1 - Import takes into multiple compositions 2 - Import takes as a
            sequence of clips
        
        - importedContainerNames : icn   (unicode)       [create]
            Internal use only. To be used along with populateImportedAnimSourcesto specify
            names for the created containers.
        
        - includeRoot : irt              (bool)          [create,edit]
            Populate transform (Translate, Rotate, Scale) of hierarchy root nodes.
        
        - isContainer : ict              (bool)          [query]
            Indicate if given clip ID is a container.
        
        - listUserGhostRoot : lug        (bool)          [query]
            Get user defined ghost root object for indicated clips.
        
        - loopEnd : le                   (time)          [query,edit]
            Loop clip's end to time.
        
        - loopStart : ls                 (time)          [query,edit]
            Loop clip's start to time.
        
        - minClipDuration : mcd          (bool)          [query]
            Returns the minimum allowed clip duration.
        
        - modifyAnimSource : mas         (bool)          [create,edit]
            When populating, automatically modify Anim Source without asking the user.
        
        - moveClip : mcl                 (time)          [edit]
            Move clip by adding delta to its start time.
        
        - mute : m                       (bool)          [query,edit]
            Mute/Unmute the clip given a clip ID. In query mode, return the muted state of
            the clip. Clips muted by soloing are not affected by this flag.
        
        - name : n                       (unicode)       [query,edit]
            Name of the clip. A clip will never have an empty name. If an empty string is
            provided, it will be replaced with _.
        
        - parent : p                     (int)           [edit]
            Specify group/object parent ID.
        
        - parentClipId : pid             (int)           [create,query]
            Specify the parent clip ID of a clip to be created.
        
        - parentGroupId : pgd            (bool)          [query]
            Return the parent group ID of the given clip.
        
        - pasteClip : pcl                (time)          [edit]
            Paste clip to the given time and track. Destination track is required to be
            specified through the track flag in the format tracksNode:trackIndex. A
            trackIndex of -1 indicates that a new track will be created.
        
        - path : pt                      (unicode)       [edit]
            Full path of the clip to be edited. For example: composition1|track1|clip1. In
            query mode, this flag can accept a value.
        
        - populateImportedAnimSources : pia (unicode)       [create]
            Internal use only. Populate the Time Editor with clips using the Animation
            Sources specified (use ; as a delimiter for multiple anim sources).
        
        - poseClip : poc                 (bool)          [create]
            Populate as pose clip with current attribute values.
        
        - preserveAnimationTiming : pat  (bool)          [create]
            When used with the population command, it ensures the animation is offset within
            a clip in such way that it matches its original scene timing, regardless of the
            new clip's position.
        
        - razorClip : rcl                (time)          [edit]
            Razor clip into two clips at the specified time.
        
        - recursively : rec              (bool)          [create,edit]
            Populate selection recursively, adding all the children.
        
        - remap : rmp                    (unicode, unicode) [edit]
            Change animation source for a given clip item to a new one, specified by the
            target path. This removes all clips for the roster item and creates new clips
            from the Anim Source for the new target path.
        
        - remapSource : rs               (unicode, unicode) [edit]
            Set animation source to be remapped for a given clip item to new one, specified
            by the target path.
        
        - remappedSourceAttrs : rms      (bool)          [query]
            Return an array of attribute indices and names of the source attributes of a
            remapped clip.
        
        - remappedTargetAttrs : rmt      (bool)          [query]
            Return an array of attribute indices and names of the target attributes of a
            remapped clip.
        
        - removeAttribute : ra           (unicode)       [edit]
            Remove attribute from the clip.
        
        - removeClip : rmc               (bool)          [edit]
            Remove clip of specified ID.
        
        - removeCrossfade : rcf          (bool)          [edit]
            Remove custom crossfade between two clips specified by -clipId flags.
        
        - removeSceneAnimation : rsa     (bool)          [create,edit]
            If true, remove animation from scene when creating clips or anim sources. Only
            Time Editor will drive the removed scene animation.
        
        - removeWeightCurve : rwc        (bool)          [create,query,edit]
            Remove the weight curve connected to the clip.
        
        - resetTiming : rt               (bool)          [edit]
            Reset start and duration of a clip with the given clip ID to the values stored
            in its Anim Source.
        
        - resetTransition : rtr          (bool)          [edit]
            Reset transition intervals between specified clips.
        
        - ripple : rpl                   (bool)          [edit]
            Apply rippling to a clip operation.
        
        - rootClipId : rti               (int)           [edit]
            ID of the root clip. It is used together with various clip editing flags. When
            used, the effect of clip editing and its parameters will be affected by the
            given root clip. For example, moving a clip under the group root (usually in
            group tab view) will be performed in the local time space of the group root.
        
        - rootPath : rpt                 (unicode)       [edit]
            Path of the root clip. It is used together with various clip editing flags. When
            used, the effect of clip editing and its parameters will be affected by the
            given root clip. For example, moving a clip under the group root (usually in
            group tab view) will be performed in the local time space of the group root.
        
        - scaleEnd : sce                 (time)          [edit]
            Scale the end time of the clip to the given time.
        
        - scalePivot : scp               (time)          [edit]
            Scale the time of the clip based on the pivot. This should be used together with
            -scs/scaleStartor -sce/scaleEnd.
        
        - scaleStart : scs               (time)          [edit]
            Scale the start time of the clip to the given time.
        
        - setKeyframe : k                (unicode)       [edit]
            Set keyframe on a specific clip for a specified attribute.
        
        - showAnimSourceRemapping : sar  (bool)          [create]
            Show a remapping dialog when the imported anim source attributes do not match
            the scene attributes.
        
        - speedRamping : src             (int)           [query,edit]
            To control the playback speed of the clip by animation curve: 1 : create -
            Attach a speed curve and a time warp curve to the clip to control the playback
            speed2 : edit - Open the Graph editor to edit the speed curve3 : enable - Create
            a time warp curve from current speed curve and attach to clip4 : disable -
            Remove the time warp curve from clip5 : delete - Delete the attached speed curve
            and time warp curve6 : reset - Reset the speed curve back to the default7 :
            convert to speed curve from time warp8 : convert to time warp from speed curveIn
            query mode, return true if a speed curve is attached to the clip.
        
        - startTime : s                  (time)          [create,query]
            Relative start time of the new clip.
        
        - takeList : tl                  (unicode)       [create]
            Internal use only. To be used along with populateImportedAnimSourcesto specify
            the imported take names.
        
        - takesToImport : toi            (unicode)       [create]
            Internal use only. To be used along with populateImportedAnimSourcesto specify
            the imported take indices.
        
        - timeWarp : tw                  (bool)          [query]
            Return true if the clip is being warped by the speed curve. If no speed curve is
            attached to the clip, it will always return false.
        
        - timeWarpCurve : twc            (bool)          [query]
            Returns the name of the time warp curve connected to the clip.
        
        - timeWarpType : twt             (int)           [query,edit]
            Time warp mode: 0: remapping - Connected time warp curve performs frame by frame
            remapping1: speed curve - Connected time warp curve acts as a speed curveIn
            query mode, return time warp mode of a clip.
        
        - track : trk                    (unicode)       [create,query,edit]
            The new clip container will be created on the track in the format
            trackNode:trackNumber, or on a track path, for example composition1|track1. In
            query mode, return a string containing the track number and tracks node of the
            given clip ID. In create mode, if the track number is '-1' or not given at all,
            then a new track will be created. For example: trackNode:-1; composition1|.
        
        - tracksNode : trn               (bool)          [query]
            Get tracks node if specified clip is a group clip.
        
        - transition : tra               (bool)          [edit]
            Create transition intervals between specified clips.
        
        - trimEnd : tre                  (time)          [edit]
            Trim the end time of the clip to the given time.
        
        - trimStart : trs                (time)          [edit]
            Trim the start time of the clip to the given time.
        
        - truncated : trc                (bool)          [query]
            This flag is used in conjunction with other timing flags like -s/start,
            -d/duration, -ed/end, etc. to query (global) truncated time.
        
        - type : typ                     (unicode)       [create,query,edit]
            Only populate the specified type of animation source.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        - uniqueAnimSource : uas         (bool)          [edit]
            If a given clip is sharing its Anim Source node with another clip, make the Anim
            Source of this clip unique.
        
        - userGhostRoot : ugr            (bool)          [query,edit]
            Edit or query custom ghost root variable. Determine whether to use user defined
            ghost root.
        
        - weightCurve : wc               (bool)          [create,query,edit]
            In edit mode, create a weight curve and connect it to the clip. In query mode,
            return the name of the weight curve connected to the clip.
        
        - zeroKeying : zk                (bool)          [edit]
            A toggle flag to use in conjunction with k/setKeyframe, set the value of the key
            frame(s) to be keyed to zero.
        
        
        Derived from mel command `maya.cmds.timeEditorClip`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Entity(ContainerBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class TypeExtrude(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvFacade(Facade):
    __melnode__ = []
    
    
    __readonly__ = {}


class SkinCluster(GeometryFilter):
    def addInfluence(self, val='True', **kwargs):
        """
        The specified transform or joint will be added to the list of transforms that influence the bound geometry. The maximum number of influences will be observed and only the weights of the cv's that the specified transform effects will change. This flag is multi-use.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def addToSelection(self, val='True', **kwargs):
        """
        When used in conjunction with the selectInfluenceVerts flag, causes the vertices afftected by the influence to be added to the current selection, without first de-selecting other vertices.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def baseShape(self, val='True', **kwargs):
        """
        This flag can be used in conjunction with the -addInfluence flag to specify the shape that will be used as the base shape when an influence object with geometry is added to the skinCluster.  If the flag is not used then the command will make a copy of the influence object's shape and use that as a base shape.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def forceNormalizeWeights(self, val='True', **kwargs):
        """
        If the normalization mode is none or post, it is possible (indeed likely) for the weights in the skin cluster to no longer add up to 1.  This flag forces all weights to add back to 1 again.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getBindMethod(self, **kwargs):
        """
        This flag sets the binding method. 0 - Closest distance between a joint and a point of the geometry. 1 - Closest distance between a joint, considering the skeleton hierarchy, and a point of the geometry. 2 - Surface heat map diffusion. 3 - Geodesic voxel binding.  geomBind command must be called after creating a skinCluster with this method.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getBlendWeights(self, path, components):
        """
        This method returns weights from skinCluster's blend weight array. These weights are used to determine the blending between classical linear skinning and dual quaternion bases skinning on a per vertex basis. The function returns the weights associated with the components passed. The components are defined on the object whose dagPath is specified.
        
        Parameters:
        path : 'PyNode'
            path to object deformed by the skinCluster
        components : 'PyNode'
            the components to return weights for
        
        
        Returns:
        List['float']
        
        Derived from api method `maya.OpenMayaAnim.MFnSkinCluster.getBlendWeights`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getDropoffRate(self, **kwargs):
        """
        Sets the rate at which the influence of a transform drops as the distance from that transform increases. The valid range is between 0.1 and 10.0.  In Create mode it sets the dropoff rate for all the bound joints.  In Edit mode the flag is used together with the inf/influence flag to set the dropoff rate of a particular influence.  Note: When the flag is used in Edit mode, any custom weights on the skin points the given transform influences will be lost.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getIgnoreHierarchy(self, **kwargs):
        """
        Deprecated. Use bindMethod flag instead. Disregard the place of the joints in the skeleton hierarchy when computing the closest joints that influence a point of the geometry.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getInfluence(self, **kwargs):
        """
        This flag specifies the influence object that will be used for the current edit operation. In query mode, returns a string array of the influence objects (joints and transform).       In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getLockWeights(self, **kwargs):
        """
        Lock the weights of the specified influence object to their current value or to the value specified by the -weight flag.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getMaximumInfluences(self, **kwargs):
        """
        Sets the maximum number of transforms that can influence a point (have non-zero weight for the point) when the skinCluster is first created or a new influence is added.  Note: When this flag is used in Edit mode any custom weights will be lost and new weights will be reassigned to the whole skin.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getNormalizeWeights(self, **kwargs):
        """
        This flag sets the normalization mode. 0 - none, 1 - interactive, 2 - post (default) Interactive normalization makes sure the weights on the influences add up to 1.0, always. Everytime a weight is changed, the weights are automatically normalized.  This may make it difficult to perform weighting operations, as the normalization may interfere with the weights the user has set.  Post normalization leaves the weights the user has set as is, and only normalizes the weights at the moment it is needed (by dividing by the sum of the weights).  This makes it easier for users to weight their skins.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getObeyMaxInfluences(self, **kwargs):
        """
        When true, the skinCluster will continue to enforce the maximum influences each time the user modifies the weight, so that any given point is only weighted by the number of influences in the skinCluster's maximumInfluences attribute.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getPointsAffectedByInfluence(self, path):
        """
        During deformation, the skinCluster algorithm is applied for a given influence object on all points in the deformer's set whose weights are non-zero. This method allows the user to query the non-zero weights for a particular influence object.
        
        Parameters:
        path : 'PyNode'
            path of the influence object
        
        
        Returns:
        Tuple['SelectionSet', List['float']]
        
        Derived from api method `maya.OpenMayaAnim.MFnSkinCluster.getPointsAffectedByInfluence`
        """
        pass
    def getSkinMethod(self, **kwargs):
        """
        This flag set the skinning method. 0 - classical linear skinning (default). 1 - dual quaternion (volume preserving), 2 - a weighted blend between the two.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getWeightDistribution(self, **kwargs):
        """
        This flag sets the weight distribution mode. 0 - distance (default), 1 - neighbors When normalizeWeights is in effect, and a weight has been reduced or removed altogether, the sum is usually brought back up to 1.0 by increasing the contributions of the other non-zero weights. However, if there are no other non-zero weights, the algorithm has to create some weights from thin air and distribute the residual weight between them. This attribute controls how that is done. Distance- the algorithm calculates weights from the world-space distances from the component to the transforms. Neighbors- the algorithm calculates weights from the weights on the neighboring components.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getWeightedInfluence(self, **kwargs):
        """
        This flag returns a string array of the influence objects (joints and transform) that have non-zero weighting.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def getWeights(self, geometry, influenceIndex='None'): pass
    def ignoreBindPose(self, val='True', **kwargs):
        """
        This flag is deprecated and no longer used.  It will be ignored if used.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def indexForInfluenceObject(self, mpath):
        """
        Returns the logical index of the matrix array attribute where the specified influence object is attached.
        
        Parameters:
        mpath : 'PyNode'
            path of the influence object
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnSkinCluster.indexForInfluenceObject`
        """
        pass
    def influenceObjects(self):
        """
        Returns an array of paths to the influence objects for the skinCluster.
        
        Returns:
        Tuple['int', List['PyNode']]
        
        Derived from api method `maya.OpenMayaAnim.MFnSkinCluster.influenceObjects`
        """
        pass
    def moveJointsMode(self, val='True', **kwargs):
        """
        If set to true, puts the skin into a mode where joints can be moved without modifying the skinning. If set to false, takes the skin out of move joints mode.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def numInfluenceObjects(self): pass
    def nurbsSamples(self, val='True', **kwargs):
        """
        Sets the number of sample points that will be used along an influence curve or in each direction on an influence NURBS surface to influence the bound skin. The more the sample points the more closely the skin follows the influence NURBS curve/surface.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def polySmoothness(self, val='True', **kwargs):
        """
        This flag controls how accurately the skin control points follow a given polygon influence object. The higher the value of polySmoothnmess the more rounded the deformation resulting from a polygonal influence object will be.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def recacheBindMatrices(self, val='True', **kwargs):
        """
        Forces the skinCluster node to recache its bind matrices.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def removeFromSelection(self, val='True', **kwargs):
        """
        When used in conjunction with the selectInfluenceVerts flag, causes the vertices afftected by the influence to be removed from the current selection.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def removeInfluence(self, val='True', **kwargs):
        """
        Remove the specified transform or joint from the list of transforms that influence the bound geometry The weights for the affected points are renormalized. This flag is multi-use.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def selectInfluenceVerts(self, val='True', **kwargs):
        """
        Given the name of a transform, this will select the verts or control points being influenced by this transform, so users may visualize which vertices are being influenced by the transform.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setBlendWeights(self, path, components, weights):
        """
        This method sets weights in skinCluster's blend weight array. These weights are used to determine the blending between classical linear skinning and dual quaternion bases skinning on a per vertex basis. The function sets the weights for the given components of the object whose dagPath is specified. The array size should match the number of components passed. Failing this, it will set the smaller of the two.
        
        Parameters:
        path : 'PyNode'
            path to object deformed by the skinCluster
        components : 'PyNode'
            the components list for the new weight values
        weights : List['float']
            the weight values (one per component in the order given)
        
        Derived from api method `maya.OpenMayaAnim.MFnSkinCluster.setBlendWeights`
        """
        pass
    def setDropoffRate(self, val='True', **kwargs):
        """
        Sets the rate at which the influence of a transform drops as the distance from that transform increases. The valid range is between 0.1 and 10.0.  In Create mode it sets the dropoff rate for all the bound joints.  In Edit mode the flag is used together with the inf/influence flag to set the dropoff rate of a particular influence.  Note: When the flag is used in Edit mode, any custom weights on the skin points the given transform influences will be lost.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setInfluence(self, val='True', **kwargs):
        """
        This flag specifies the influence object that will be used for the current edit operation. In query mode, returns a string array of the influence objects (joints and transform).       In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setLockWeights(self, val='True', **kwargs):
        """
        Lock the weights of the specified influence object to their current value or to the value specified by the -weight flag.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setMaximumInfluences(self, val='True', **kwargs):
        """
        Sets the maximum number of transforms that can influence a point (have non-zero weight for the point) when the skinCluster is first created or a new influence is added.  Note: When this flag is used in Edit mode any custom weights will be lost and new weights will be reassigned to the whole skin.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setNormalizeWeights(self, val='True', **kwargs):
        """
        This flag sets the normalization mode. 0 - none, 1 - interactive, 2 - post (default) Interactive normalization makes sure the weights on the influences add up to 1.0, always. Everytime a weight is changed, the weights are automatically normalized.  This may make it difficult to perform weighting operations, as the normalization may interfere with the weights the user has set.  Post normalization leaves the weights the user has set as is, and only normalizes the weights at the moment it is needed (by dividing by the sum of the weights).  This makes it easier for users to weight their skins.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setObeyMaxInfluences(self, val='True', **kwargs):
        """
        When true, the skinCluster will continue to enforce the maximum influences each time the user modifies the weight, so that any given point is only weighted by the number of influences in the skinCluster's maximumInfluences attribute.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setSkinMethod(self, val='True', **kwargs):
        """
        This flag set the skinning method. 0 - classical linear skinning (default). 1 - dual quaternion (volume preserving), 2 - a weighted blend between the two.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setWeightDistribution(self, val='True', **kwargs):
        """
        This flag sets the weight distribution mode. 0 - distance (default), 1 - neighbors When normalizeWeights is in effect, and a weight has been reduced or removed altogether, the sum is usually brought back up to 1.0 by increasing the contributions of the other non-zero weights. However, if there are no other non-zero weights, the algorithm has to create some weights from thin air and distribute the residual weight between them. This attribute controls how that is done. Distance- the algorithm calculates weights from the world-space distances from the component to the transforms. Neighbors- the algorithm calculates weights from the weights on the neighboring components.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def setWeights(self, geometry, influnces, weights, normalize='True'): pass
    def smoothWeights(self, val='True', **kwargs):
        """
        This flag is used to detect sudden jumps in skin weight values, which often indicates bad weighting, and then smooth out those jaggies in skin weights. The argument is the error tolerance ranging from 0 to 1.  A value of 1 means that the algorithm will smooth a vertex only if there is a 100% change in weight values from its neighbors.  The recommended default to use is 0.5 (50% change in weight value from the neighbors).                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def smoothWeightsMaxIterations(self, val='True', **kwargs):
        """
        This flag is valid only with the smooth weights flag.  It is possible that not all the vertices detected as needing smoothing can be smoothed in 1 iteration (because all of their neighbors also have bad weighting and need to be smoothed). With more iterations, more vertices can be smoothed.  This flag controls the maximum number of iterations the algorithm will attempt to smooth weights. The default is 2 for this flag.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def unbind(self, val='True', **kwargs):
        """
        Unbinds the geometry from the skinCluster and deletes the skinCluster node                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def unbindKeepHistory(self, val='True', **kwargs):
        """
        Unbinds the geometry from the skinCluster, but keeps the skinCluster node so that its weights can be used when the skin is rebound. To rebind, use the skinCluster command.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def useGeometry(self, val='True', **kwargs):
        """
        When adding an influence to a skinCluster, use the geometry parented under the influence transform to determine the weight dropoff of that influence.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    def weight(self, val='True', **kwargs):
        """
        This flag is only valid in conjunction with the -addInfluence flag. It sets the weight for the influence object that is being added.                  
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The skinCluster command is used for smooth skinning in maya. It binds the
        selected geometry to the selected joints or skeleton by means of a skinCluster
        node.  Each point of the bound geometry can be affected by any number of joints.
        The extent to which each joint affects the motion of each point is regulated by
        a corresponding weight factor.  Weight factors can be modified using the
        skinPercent command.  The command returns the name of the new skinCluster.The
        skinCluster binds only a single geometry at a time. Thus, to bind multiple
        geometries, multiple skinCluster commands must be issued.Upon creation of a new
        skinCluster, the command can be used to add and remove transforms (not
        necessarily joints) that influence the motion of the bound skin points.  The
        skinCluster command can also be used to adjust parameters such as the dropoff,
        nurbs samples, polygon smoothness on a particular influence object. Note: Any
        custom weights on a skin point that the influence object affects will be lost
        after adjusting these parameters.
        
        Flags:
        - addInfluence : ai              (unicode)       [edit]
            The specified transform or joint will be added to the list of transforms that
            influence the bound geometry. The maximum number of influences will be observed
            and only the weights of the cv's that the specified transform effects will
            change. This flag is multi-use.
        
        - addToSelection : ats           (bool)          [edit]
            When used in conjunction with the selectInfluenceVerts flag, causes the vertices
            afftected by the influence to be added to the current selection, without first
            de-selecting other vertices.
        
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - baseShape : bsh                (unicode)       [edit]
            This flag can be used in conjunction with the -addInfluence flag to specify the
            shape that will be used as the base shape when an influence object with geometry
            is added to the skinCluster.  If the flag is not used then the command will make
            a copy of the influence object's shape and use that as a base shape.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - bindMethod : bm                (int)           [create,query]
            This flag sets the binding method. 0 - Closest distance between a joint and a
            point of the geometry. 1 - Closest distance between a joint, considering the
            skeleton hierarchy, and a point of the geometry. 2 - Surface heat map diffusion.
            3 - Geodesic voxel binding.  geomBind command must be called after creating a
            skinCluster with this method.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - dropoffRate : dr               (float)         [create,query,edit]
            Sets the rate at which the influence of a transform drops as the distance from
            that transform increases. The valid range is between 0.1 and 10.0.  In Create
            mode it sets the dropoff rate for all the bound joints.  In Edit mode the flag
            is used together with the inf/influence flag to set the dropoff rate of a
            particular influence.  Note: When the flag is used in Edit mode, any custom
            weights on the skin points the given transform influences will be lost.
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - forceNormalizeWeights : fnw    (bool)          [edit]
            If the normalization mode is none or post, it is possible (indeed likely) for
            the weights in the skin cluster to no longer add up to 1.  This flag forces all
            weights to add back to 1 again.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - heatmapFalloff : hmf           (float)         [create]
            This flag sets the heatmap binding falloff. If set to 0.0 (default) the
            deformation will be smoother due to many small weights spread over the mesh
            surface per influence. However, if set to 1.0, corresponding to maximum falloff,
            the number of influences per point will be reduced and points will tend to be
            greatly influenced by their closest joint decreasing the overall spread of small
            weights. This flag only works when using heatmap binding.
        
        - ignoreBindPose : ibp           (bool)          [create,edit]
            This flag is deprecated and no longer used.  It will be ignored if used.
        
        - ignoreHierarchy : ih           (bool)          [create,query]
            Deprecated. Use bindMethod flag instead. Disregard the place of the joints in
            the skeleton hierarchy when computing the closest joints that influence a point
            of the geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - influence : inf                (unicode)       [query,edit]
            This flag specifies the influence object that will be used for the current edit
            operation. In query mode, returns a string array of the influence objects
            (joints and transform).       In query mode, this flag can accept a value.
        
        - lockWeights : lw               (bool)          [query,edit]
            Lock the weights of the specified influence object to their current value or to
            the value specified by the -weight flag.
        
        - maximumInfluences : mi         (int)           [create,query,edit]
            Sets the maximum number of transforms that can influence a point (have non-zero
            weight for the point) when the skinCluster is first created or a new influence
            is added.  Note: When this flag is used in Edit mode any custom weights will be
            lost and new weights will be reassigned to the whole skin.
        
        - moveJointsMode : mjm           (bool)          [edit]
            If set to true, puts the skin into a mode where joints can be moved without
            modifying the skinning. If set to false, takes the skin out of move joints mode.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - normalizeWeights : nw          (int)           [create,query,edit]
            This flag sets the normalization mode. 0 - none, 1 - interactive, 2 - post
            (default) Interactive normalization makes sure the weights on the influences add
            up to 1.0, always. Everytime a weight is changed, the weights are automatically
            normalized.  This may make it difficult to perform weighting operations, as the
            normalization may interfere with the weights the user has set.  Post
            normalization leaves the weights the user has set as is, and only normalizes the
            weights at the moment it is needed (by dividing by the sum of the weights).
            This makes it easier for users to weight their skins.
        
        - nurbsSamples : ns              (int)           [create,edit]
            Sets the number of sample points that will be used along an influence curve or
            in each direction on an influence NURBS surface to influence the bound skin. The
            more the sample points the more closely the skin follows the influence NURBS
            curve/surface.
        
        - obeyMaxInfluences : omi        (bool)          [create,query,edit]
            When true, the skinCluster will continue to enforce the maximum influences each
            time the user modifies the weight, so that any given point is only weighted by
            the number of influences in the skinCluster's maximumInfluences attribute.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - polySmoothness : ps            (float)         [create,edit]
            This flag controls how accurately the skin control points follow a given polygon
            influence object. The higher the value of polySmoothnmess the more rounded the
            deformation resulting from a polygonal influence object will be.
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - recacheBindMatrices : rbm      (bool)          [edit]
            Forces the skinCluster node to recache its bind matrices.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - removeFromSelection : rfs      (bool)          [edit]
            When used in conjunction with the selectInfluenceVerts flag, causes the vertices
            afftected by the influence to be removed from the current selection.
        
        - removeInfluence : ri           (unicode)       [edit]
            Remove the specified transform or joint from the list of transforms that
            influence the bound geometry The weights for the affected points are
            renormalized. This flag is multi-use.
        
        - removeUnusedInfluence : rui    (bool)          [create]
            If this flag is set to true then transform or joint whose weights are all zero
            (they have no effect) will not be bound to the geometry.  Having this option set
            will help speed-up the playback of animation.
        
        - selectInfluenceVerts : siv     (unicode)       [edit]
            Given the name of a transform, this will select the verts or control points
            being influenced by this transform, so users may visualize which vertices are
            being influenced by the transform.
        
        - skinMethod : sm                (int)           [create,query,edit]
            This flag set the skinning method. 0 - classical linear skinning (default). 1 -
            dual quaternion (volume preserving), 2 - a weighted blend between the two.
        
        - smoothWeights : sw             (float)         [edit]
            This flag is used to detect sudden jumps in skin weight values, which often
            indicates bad weighting, and then smooth out those jaggies in skin weights. The
            argument is the error tolerance ranging from 0 to 1.  A value of 1 means that
            the algorithm will smooth a vertex only if there is a 100% change in weight
            values from its neighbors.  The recommended default to use is 0.5 (50% change in
            weight value from the neighbors).
        
        - smoothWeightsMaxIterations : swi (int)           [edit]
            This flag is valid only with the smooth weights flag.  It is possible that not
            all the vertices detected as needing smoothing can be smoothed in 1 iteration
            (because all of their neighbors also have bad weighting and need to be
            smoothed). With more iterations, more vertices can be smoothed.  This flag
            controls the maximum number of iterations the algorithm will attempt to smooth
            weights. The default is 2 for this flag.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - toSelectedBones : tsb          (bool)          [create]
            geometry will be bound to the selected bones only.
        
        - toSkeletonAndTransforms : tst  (bool)          [create]
            geometry will be bound to the skeleton and any transforms in the hierarchy. If
            any of the transforms are also bindable objects, assume that only the last
            object passed to the command is the bindable object. The rest are treated as
            influences.
        
        - unbind : ub                    (bool)          [edit]
            Unbinds the geometry from the skinCluster and deletes the skinCluster node
        
        - unbindKeepHistory : ubk        (bool)          [edit]
            Unbinds the geometry from the skinCluster, but keeps the skinCluster node so
            that its weights can be used when the skin is rebound. To rebind, use the
            skinCluster command.
        
        - useGeometry : ug               (bool)          [edit]
            When adding an influence to a skinCluster, use the geometry parented under the
            influence transform to determine the weight dropoff of that influence.
        
        - volumeBind : vb                (float)         [create]
            Creates a volume bind node and attaches it to the new skin cluster node. This
            node holds hull geometry parameters for a volume based weighting system. This
            system is used in interactive skinning. The value passed will determine the
            minimum weight value when initializing the volume. The volume in be increase to
            enclose all the vertices that are above this value.
        
        - volumeType : vt                (int)           [create]
            Defines the initial shape of the binding volume (see volumeBind). 0 - Default
            (currently set to a capsule) 1 - Capsule, 2 - Cylinder.
        
        - weight : wt                    (float)         [edit]
            This flag is only valid in conjunction with the -addInfluence flag. It sets the
            weight for the influence object that is being added.
        
        - weightDistribution : wd        (int)           [create,query,edit]
            This flag sets the weight distribution mode. 0 - distance (default), 1 -
            neighbors When normalizeWeights is in effect, and a weight has been reduced or
            removed altogether, the sum is usually brought back up to 1.0 by increasing the
            contributions of the other non-zero weights. However, if there are no other non-
            zero weights, the algorithm has to create some weights from thin air and
            distribute the residual weight between them. This attribute controls how that is
            done. Distance- the algorithm calculates weights from the world-space distances
            from the component to the transforms. Neighbors- the algorithm calculates
            weights from the weights on the neighboring components.
        
        - weightedInfluence : wi         (bool)          [query]
            This flag returns a string array of the influence objects (joints and transform)
            that have non-zero weighting.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.skinCluster`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatSlerp(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuatInvert(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OffsetSurface(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    def getDistance(self, **kwargs):
        """
        Offset distance Default:1.0                  
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    def getMethod(self, **kwargs):
        """
        Offset method 0 - Surface Fit 1 - CV Fit Default:0                  
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    def setDistance(self, val='True', **kwargs):
        """
        Offset distance Default:1.0                  
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    def setMethod(self, val='True', **kwargs):
        """
        Offset method 0 - Surface Fit 1 - CV Fit Default:0                  
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The offset command creates new offset surfaces from the selected surfaces. The
        default method is a surface offset, which offsets relative to the surface
        itself. The CV offset method offsets the CVs directly rather than the surface,
        so is usually slightly less accurate but is faster. The offset surface will
        always have the same degree, number of CVs and knot spacing as the original
        surface.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - distance : d                   (float)         [create,query,edit]
            Offset distance Default:1.0
        
        - frozen : fzn                   (bool)          []
        
        - method : m                     (int)           [create,query,edit]
            Offset method 0 - Surface Fit 1 - CV Fit Default:0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.offsetSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbCircle(AbstractBaseCreate):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getCenter(self, **kwargs):
        """
        The center point of the circle.                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getCenterX(self, **kwargs):
        """
        X of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getCenterY(self, **kwargs):
        """
        Y of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getCenterZ(self, **kwargs):
        """
        Z of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting circle: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getFirst(self, **kwargs):
        """
        The start point of the circle if fixCenter is false. Determines the orientation of the circle if fixCenter is true.                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getFirstPointX(self, **kwargs):
        """
        X of the first point. Default:1                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getFirstPointY(self, **kwargs):
        """
        Y of the first point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getFirstPointZ(self, **kwargs):
        """
        Z of the first point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getFixCenter(self, **kwargs):
        """
        Fix the center of the circle to the specified center point. Otherwise the circle will start at the specified first point. Default:true                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getNormal(self, **kwargs):
        """
        The normal of the plane in which the circle will lie.                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getNormalX(self, **kwargs):
        """
        X of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getNormalY(self, **kwargs):
        """
        Y of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getNormalZ(self, **kwargs):
        """
        Z of the normal direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getRadius(self, **kwargs):
        """
        The radius of the circle. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getSections(self, **kwargs):
        """
        The number of sections determines the resolution of the circle. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getSweep(self, **kwargs):
        """
        The sweep angle determines the completeness of the circle. A full circle is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to build a circle. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def getUseTolerance(self, **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setCenter(self, val='True', **kwargs):
        """
        The center point of the circle.                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setCenterX(self, val='True', **kwargs):
        """
        X of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setCenterY(self, val='True', **kwargs):
        """
        Y of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setCenterZ(self, val='True', **kwargs):
        """
        Z of the center point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting circle: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setFirst(self, val='True', **kwargs):
        """
        The start point of the circle if fixCenter is false. Determines the orientation of the circle if fixCenter is true.                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setFirstPointX(self, val='True', **kwargs):
        """
        X of the first point. Default:1                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setFirstPointY(self, val='True', **kwargs):
        """
        Y of the first point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setFirstPointZ(self, val='True', **kwargs):
        """
        Z of the first point. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setFixCenter(self, val='True', **kwargs):
        """
        Fix the center of the circle to the specified center point. Otherwise the circle will start at the specified first point. Default:true                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setNormal(self, val='True', **kwargs):
        """
        The normal of the plane in which the circle will lie.                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setNormalX(self, val='True', **kwargs):
        """
        X of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setNormalY(self, val='True', **kwargs):
        """
        Y of the normal direction. Default:0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setNormalZ(self, val='True', **kwargs):
        """
        Z of the normal direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        The radius of the circle. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setSections(self, val='True', **kwargs):
        """
        The number of sections determines the resolution of the circle. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setSweep(self, val='True', **kwargs):
        """
        The sweep angle determines the completeness of the circle. A full circle is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to build a circle. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    def setUseTolerance(self, val='True', **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The circle command creates a circle or partial circle (arc)
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - center : c                     (float, float, float) [create,query,edit]
            The center point of the circle.
        
        - centerX : cx                   (float)         [create,query,edit]
            X of the center point. Default:0
        
        - centerY : cy                   (float)         [create,query,edit]
            Y of the center point. Default:0
        
        - centerZ : cz                   (float)         [create,query,edit]
            Z of the center point. Default:0
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting circle: 1 - linear, 3 - cubic Default:3
        
        - first : fp                     (float, float, float) [create,query,edit]
            The start point of the circle if fixCenter is false. Determines the orientation
            of the circle if fixCenter is true.
        
        - firstPointX : fpx              (float)         [create,query,edit]
            X of the first point. Default:1
        
        - firstPointY : fpy              (float)         [create,query,edit]
            Y of the first point. Default:0
        
        - firstPointZ : fpz              (float)         [create,query,edit]
            Z of the first point. Default:0
        
        - fixCenter : fc                 (bool)          [create,query,edit]
            Fix the center of the circle to the specified center point. Otherwise the circle
            will start at the specified first point. Default:true
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - normal : nr                    (float, float, float) [create,query,edit]
            The normal of the plane in which the circle will lie.
        
        - normalX : nrx                  (float)         [create,query,edit]
            X of the normal direction. Default:0
        
        - normalY : nry                  (float)         [create,query,edit]
            Y of the normal direction. Default:0
        
        - normalZ : nrz                  (float)         [create,query,edit]
            Z of the normal direction. Default:1
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        - radius : r                     (float)         [create,query,edit]
            The radius of the circle. Default:1.0
        
        - sections : s                   (int)           [create,query,edit]
            The number of sections determines the resolution of the circle. Used only if
            useTolerance is false. Default:8
        
        - sweep : sw                     (float)         [create,query,edit]
            The sweep angle determines the completeness of the circle. A full circle is 2Pi
            radians, or 360 degrees. Default:6.2831853
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to build a circle. Used only if useTolerance is true
            Default:0.01
        
        - useTolerance : ut              (bool)          [create,query,edit]
            Use the specified tolerance to determine resolution. Otherwise number of
            sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.circle`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'circle'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiUserDataFloat(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubstanceOutput(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class StitchAsNurbsShell(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_BaseNode(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FloatComposite(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectMultiFilter(ObjectFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class Premultiply(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmHairMapping(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SvgToPoly(THdependNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AbstractBaseNurbsConversion(AbstractBaseCreate):
    __melnode__ = []
    
    
    __readonly__ = {}


class ShrinkWrap(WeightGeometryFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyTriangulate(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyTriangulate`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyTriangulate`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyTriangulate`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyTriangulate`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyTriangulate`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Triangulation breaks polygons down into triangles, ensuring that all faces are
        planar and non-holed. Triangulation of models can be beneficial in many areas.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyTriangulate`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DoubleShadingSwitch(BaseShadingSwitch):
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromSurface(CurveRange):
    __melnode__ = []
    
    
    __readonly__ = {}


class Tension(WeightGeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getInwardConstraint(self, **kwargs):
        """
        Constrains the movement of the vertex to not move inward from the input deforming shape to preserve the contour. Value is in the [0,1] range. Default is 0.0.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getOutwardConstraint(self, **kwargs):
        """
        Constrains the movement of the vertex to not move outward from the input deforming shape to preserve the contour. Value is in the [0,1] range.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getPinBorderVertices(self, **kwargs):
        """
        If enabled, vertices on mesh borders will be pinned to their current position during smoothing. Default is true.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getSmoothingIterations(self, **kwargs):
        """
        Number of smoothing iterations performed by the tension node. Default is 10.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def getSmoothingStep(self, **kwargs):
        """
        Step amount used per smoothing iteration. Value is clamped to [0, 1] range. A higher value may lead to instabilities but converges faster compared to a lower value. Default is 0.5.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def setInwardConstraint(self, val='True', **kwargs):
        """
        Constrains the movement of the vertex to not move inward from the input deforming shape to preserve the contour. Value is in the [0,1] range. Default is 0.0.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def setOutwardConstraint(self, val='True', **kwargs):
        """
        Constrains the movement of the vertex to not move outward from the input deforming shape to preserve the contour. Value is in the [0,1] range.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def setPinBorderVertices(self, val='True', **kwargs):
        """
        If enabled, vertices on mesh borders will be pinned to their current position during smoothing. Default is true.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def setSmoothingIterations(self, val='True', **kwargs):
        """
        Number of smoothing iterations performed by the tension node. Default is 10.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    def setSmoothingStep(self, val='True', **kwargs):
        """
        Step amount used per smoothing iteration. Value is clamped to [0, 1] range. A higher value may lead to instabilities but converges faster compared to a lower value. Default is 0.5.                  
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create, edit and query tension nodes.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - envelope : en                  (float)         [create,query,edit]
            Envelope of the tension node. The envelope determines the percent of
            deformation. Value is clamped to [0, 1] range. Default is 1.
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - inwardConstraint : iwc         (float)         [create,query,edit]
            Constrains the movement of the vertex to not move inward from the input
            deforming shape to preserve the contour. Value is in the [0,1] range. Default is
            0.0.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - outwardConstraint : owc        (float)         [create,query,edit]
            Constrains the movement of the vertex to not move outward from the input
            deforming shape to preserve the contour. Value is in the [0,1] range.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - pinBorderVertices : pbv        (bool)          [create,query,edit]
            If enabled, vertices on mesh borders will be pinned to their current position
            during smoothing. Default is true.
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - smoothingIterations : si       (int)           [create,query,edit]
            Number of smoothing iterations performed by the tension node. Default is 10.
        
        - smoothingStep : ss             (float)         [create,query,edit]
            Step amount used per smoothing iteration. Value is clamped to [0, 1] range. A
            higher value may lead to instabilities but converges faster compared to a lower
            value. Default is 0.5.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.tension`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyUVRectangle(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyUVRectangle`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyUVRectangle`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyUVRectangle`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyUVRectangle`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyUVRectangle`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Given two vertices, does one of the following: 1) If the vertices define
        opposite corners of a rectangular area of quads, assigns a grid of UVs spanning
        the 0-1 area to that rectangle. 2) If the vertices define an edge in a
        rectangular and topologically cylindrical area of quads, assigns UVs spanning
        the 0-1 area to that cylindrical patch, using the defined edge as the U=0 edge.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyUVRectangle`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SingleShadingSwitch(BaseShadingSwitch):
    __melnode__ = []
    
    
    __readonly__ = {}


class TextureDeformer(WeightGeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a texture deformer for the object. The selected objects are
        the input geometry objects. The deformer node name will be returned.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - direction : d                  (unicode)       [create]
            Set the deformation direction of texture deformer It can only handle three
            types: Normal, Handleand Vector. Normaleach vertices use its own normal vector.
            Handleall vertices use Up vector of the handle. Vectoreach vertices use RGB
            color vector strings.
        
        - envelope : en                  (float)         [create]
            Set the envelope of texture deformer. Envelope determines the percent of
            deformation. The final result is (color \* normal \* strength + offset) \*
            envelope
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - offset : o                     (float)         [create]
            Set the offset of texture deformer. Offset plus a translation on the final
            deformed vertices.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - pointSpace : ps                (unicode)       [create]
            Set the point space of texture deformer. It can only handle three strings:
            World, Localand UV. Worldmap world space to color space. Localmap local space to
            color space. UVmap UV space to color space. strings.
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - strength : s                   (float)         [create]
            Set the strength of texture deformer. Strength determines how strong the object
            is deformed.
        
        - vectorOffset : vo              (float, float, float) [create]
            Set the vector offset of texture deformer. Vector offset indicates the offset of
            the deformation on the vector mode.
        
        - vectorSpace : vsp              (unicode)       [create]
            Set the vector space of texture deformer. It can only handle three strings:
            Object, Worldand Tangent. Objectuse color vector in object space Worlduse color
            vector in world space Tangentuse color vector in tangent space strings.
        
        - vectorStrength : vs            (float, float, float) [create]
            Set the vector strength of texture deformer. Vector strength determines how
            strong the object is deformed on the vector mode.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.textureDeformer`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyDuplicateEdge(PolyModifier):
    def getAdjustEdgeFlow(self, **kwargs):
        """
        The weight value of the edge vertices to be positioned.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getDeleteEdge(self, **kwargs):
        """
        When true, the end edges are deleted so the end triangles are converted to quads.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getEndVertexOffset(self, **kwargs):
        """
        Weight value controlling the offset of the end vertex of the edgeloop.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getInsertWithEdgeFlow(self, **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getSmoothingAngle(self, **kwargs):
        """
        Angle below which new edges will be smoothed                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getSplitType(self, **kwargs):
        """
        Format: 0 - Absolute, 1 - Relative, 2 - Multi                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def getStartVertexOffset(self, **kwargs):
        """
        Weight value controlling the offset of the start vertex of the edgeloop.                  Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setAdjustEdgeFlow(self, val='True', **kwargs):
        """
        The weight value of the edge vertices to be positioned.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setDeleteEdge(self, val='True', **kwargs):
        """
        When true, the end edges are deleted so the end triangles are converted to quads.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setEndVertexOffset(self, val='True', **kwargs):
        """
        Weight value controlling the offset of the end vertex of the edgeloop.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setInsertWithEdgeFlow(self, val='True', **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled.                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setSmoothingAngle(self, val='True', **kwargs):
        """
        Angle below which new edges will be smoothed                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setSplitType(self, val='True', **kwargs):
        """
        Format: 0 - Absolute, 1 - Relative, 2 - Multi                  
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    def setStartVertexOffset(self, val='True', **kwargs):
        """
        Weight value controlling the offset of the start vertex of the edgeloop.                  Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Duplicates a series of connected edges (edgeLoop)
        
        Flags:
        - adjustEdgeFlow : aef           (float)         [create,query,edit]
            The weight value of the edge vertices to be positioned.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - deleteEdge : de                (bool)          [create,query,edit]
            When true, the end edges are deleted so the end triangles are converted to
            quads.
        
        - endVertexOffset : evo          (float)         [create,query,edit]
            Weight value controlling the offset of the end vertex of the edgeloop.
        
        - frozen : fzn                   (bool)          []
        
        - insertWithEdgeFlow : ief       (bool)          [create,query,edit]
            True to enable edge flow. Otherwise, the edge flow is disabled.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - offset : of                    (float)         [create]
            Weight value controlling the relative positioning of the new edges. The range of
            values is [0.0, 1.0].
        
        - smoothingAngle : sma           (float)         [create,query,edit]
            Angle below which new edges will be smoothed
        
        - splitType : stp                (int)           [create,query,edit]
            Format: 0 - Absolute, 1 - Relative, 2 - Multi
        
        - startVertexOffset : svo        (float)         [create,query,edit]
            Weight value controlling the offset of the start vertex of the edgeloop.
            Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polyDuplicateEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdCleanTopology(SubdModifier):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command cleans topology of subdiv surfaces - at all levels. It cleans the
        geometry of vertices that satisfy the following conditions:                 -
        Zero edits                 - Default uvs (uvs obtained by subdividing parent
        face).                 - No creases.
        
        
        Derived from mel command `maya.cmds.subdCleanTopology`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_World(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DpBirailSrf(BirailSrf):
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvFog(LightFog):
    __melnode__ = []
    
    
    __readonly__ = {}


class DeltaMush(WeightGeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getInwardConstraint(self, **kwargs):
        """
        Constrains the movement of the vertex to not move inward from the input deforming shape to preserve the contour. Value is in the [0,1] range. Default is 0.0.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getOutwardConstraint(self, **kwargs):
        """
        Constrains the movement of the vertex to not move outward from the input deforming shape to preserve the contour. Value is in the [0,1] range. Default is 0.0.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getPinBorderVertices(self, **kwargs):
        """
        If enabled, vertices on mesh borders will be pinned to their current position during smoothing. Default is true.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getSmoothingIterations(self, **kwargs):
        """
        Number of smoothing iterations performed by the delta mush node. Default is 10.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def getSmoothingStep(self, **kwargs):
        """
        Step amount used per smoothing iteration. Value is clamped to [0, 1] range. A higher value may lead to instabilities but converges faster compared to a lower value. Default is 0.5.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def setInwardConstraint(self, val='True', **kwargs):
        """
        Constrains the movement of the vertex to not move inward from the input deforming shape to preserve the contour. Value is in the [0,1] range. Default is 0.0.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def setOutwardConstraint(self, val='True', **kwargs):
        """
        Constrains the movement of the vertex to not move outward from the input deforming shape to preserve the contour. Value is in the [0,1] range. Default is 0.0.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def setPinBorderVertices(self, val='True', **kwargs):
        """
        If enabled, vertices on mesh borders will be pinned to their current position during smoothing. Default is true.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def setSmoothingIterations(self, val='True', **kwargs):
        """
        Number of smoothing iterations performed by the delta mush node. Default is 10.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    def setSmoothingStep(self, val='True', **kwargs):
        """
        Step amount used per smoothing iteration. Value is clamped to [0, 1] range. A higher value may lead to instabilities but converges faster compared to a lower value. Default is 0.5.                  
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create, edit and query deltaMush nodes.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - envelope : en                  (float)         [create,query,edit]
            Envelope of the delta mush node. The envelope determines the percent of
            deformation. Value is clamped to [0, 1] range. Default is 1.
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - inwardConstraint : iwc         (float)         [create,query,edit]
            Constrains the movement of the vertex to not move inward from the input
            deforming shape to preserve the contour. Value is in the [0,1] range. Default is
            0.0.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - outwardConstraint : owc        (float)         [create,query,edit]
            Constrains the movement of the vertex to not move outward from the input
            deforming shape to preserve the contour. Value is in the [0,1] range. Default is
            0.0.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - pinBorderVertices : pbv        (bool)          [create,query,edit]
            If enabled, vertices on mesh borders will be pinned to their current position
            during smoothing. Default is true.
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - smoothingIterations : si       (int)           [create,query,edit]
            Number of smoothing iterations performed by the delta mush node. Default is 10.
        
        - smoothingStep : ss             (float)         [create,query,edit]
            Step amount used per smoothing iteration. Value is clamped to [0, 1] range. A
            higher value may lead to instabilities but converges faster compared to a lower
            value. Default is 0.5.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.deltaMush`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMapCut(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    def getMoveratio(self, **kwargs):
        """
        Cut open ratio related to the neighbor edge length of cut edge.                  
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    def setMoveratio(self, val='True', **kwargs):
        """
        Cut open ratio related to the neighbor edge length of cut edge.                  
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Cut along edges of the texture mapping. The cut edges become map borders.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - moveRatio : mr                 (float)         []
        
        - moveratio : mvr                (float)         [query,edit]
            Cut open ratio related to the neighbor edge length of cut edge.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMapCut`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Brownian(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class THhwShader(HwShader):
    __melnode__ = []
    
    
    __readonly__ = {}


class SubCurve(CurveRange):
    __melnode__ = []
    
    
    __readonly__ = {}


class THdeformer(WeightGeometryFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySubdFace(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class Mandelbrot3D(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierCut(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Placer(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Cluster(WeightGeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def getWeightedNode(self, **kwargs):
        """
        Transform node in the DAG above the cluster to which all percents are applied. The second DAGobject specifies the descendent of the first DAGobject from where the transformation matrix is evaluated. Default is the cluster handle.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def resetGeometry(self, val='True', **kwargs):
        """
        Reset the geometry matrices for the objects being deformed by the cluster. This flag is used to get rid of undesirable effects that happen if you scale an object that is deformed by a cluster.                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    def setWeightedNode(self, val='True', **kwargs):
        """
        Transform node in the DAG above the cluster to which all percents are applied. The second DAGobject specifies the descendent of the first DAGobject from where the transformation matrix is evaluated. Default is the cluster handle.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The cluster command creates a cluster or edits the membership of an existing
        cluster. The command returns the name of the cluster node upon creation of a new
        cluster. After creating a cluster, the cluster's weights can be modified using
        the percent command or the set editor window.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - bindState : bs                 (bool)          [create]
            When turned on, this flag adds in a compensation to ensure the clustered objects
            preserve their spatial position when clustered. This is required to prevent the
            geometry from jumping at the time the cluster is created in situations when the
            cluster transforms at cluster time are not identity.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - envelope : en                  (float)         [create,query,edit]
            Set the envelope value for the deformer. Default is 1.0
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - relative : rel                 (bool)          [create]
            Enable relative mode for the cluster. In relative mode, Only the transformations
            directly above the cluster are used by the cluster. Default is off.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - resetGeometry : rg             (bool)          [edit]
            Reset the geometry matrices for the objects being deformed by the cluster. This
            flag is used to get rid of undesirable effects that happen if you scale an
            object that is deformed by a cluster.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - weightedNode : wn              (unicode, unicode) [create,query,edit]
            Transform node in the DAG above the cluster to which all percents are applied.
            The second DAGobject specifies the descendent of the first DAGobject from where
            the transformation matrix is evaluated. Default is the cluster handle.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.cluster`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyDelFacet(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDelFacet`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyDelFacet`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDelFacet`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDelFacet`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDelFacet`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Deletes faces. If the result is split into disconnected pieces, the pieces (so-
        called shells) are still considered to be one object. Notice : The last face
        cannot be deleted.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyDelFacet`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Leather(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class TransferAttributes(WeightGeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def colorBorders(self, val='True', **kwargs):
        """
        Controls whether color borders are preserved when transferring color data. If this is non-zero, any color borders will be mapped onto the nearest edge on the target geometry. 0 means any color borders will be smoothly blended onto the vertices of the target geometry.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def flipUVs(self, val='True', **kwargs):
        """
        Controls how sampled UV data is flipped before being transferred to the target. 0 means no flipping; 1 means UV data is flipped in the U direction; 2 means UV data is flipped in the V direction; and 3 means it is flipped in both directions. In conjunction with mirroring, this allows the creation of symmetric UV mappings (e.g. the left hand side of the character on one side of the UV map, the right hand side on the other).                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def matchChoice(self, val='True', **kwargs):
        """
        When using topological component matching, selects between possible matches. If the meshes involved in the transfer operation have symmetries in their topologies, there may be more than one possible topological match. Maya scores the possible matches (by comparing the shapes of the meshes) and assigns them an index, starting at zero. Match zero, the default, is considered the best, but in the event that Maya chooses the wrong one, changing this value will allow the user to explore the other matches.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def sampleSpace(self, val='True', **kwargs):
        """
        Selects which space the attribute transfer is performed in. 0 is world space, 1 is model space, 4 is component-based, 5 is topology-based. The default is world space.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def searchMethod(self, val='True', **kwargs):
        """
        Specifies which search method to use when correlating points. 0 is closest along normal, 3 is closest to point. The default is closest to point.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def searchScaleX(self, val='True', **kwargs):
        """
        Specifies an optional scale that should be applied to the x-axis of the target model before transferring data. A value of 1.0 (the default) means no scaling; a value of -1.0 would indicate mirroring along the x-axis.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def searchScaleY(self, val='True', **kwargs):
        """
        Specifies an optional scale that should be applied to the y-axis of the target model before transferring data. A value of 1.0 (the default) means no scaling; a value of -1.0 would indicate mirroring along the y-axis.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def searchScaleZ(self, val='True', **kwargs):
        """
        Specifies an optional scale that should be applied to the z-axis of the target model before transferring data. A value of 1.0 (the default) means no scaling; a value of -1.0 would indicate mirroring along the z-axis.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def transferColors(self, val='True', **kwargs):
        """
        Controls color set transfer. 0 means no color sets are transferred, 1 means that a single color set (specified by sourceColorSet and targetColorSet) is transferred, and 2 means that all color sets are transferred.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def transferNormals(self, val='True', **kwargs):
        """
        A non-zero value indicates vertex normals should be sampled and written into user normals on the target surface.                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def transferPositions(self, val='True', **kwargs):
        """
        A non-zero value indicates vertex position should be sampled, causing the target surface to wrapto the source surface(s).                  
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    def transferUVs(self, val='True', **kwargs):
        """
        Controls UV set transfer. 0 means no UV sets are transferred, 1 means that a single UV set (specified by sourceUVSet and targetUVSet) is transferred, and 2 means that all UV sets are transferred.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Samples the attributes of a source surface (first argument) and transfers them
        onto a target surface (second argument).
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - colorBorders : clb             (int)           [create,edit]
            Controls whether color borders are preserved when transferring color data. If
            this is non-zero, any color borders will be mapped onto the nearest edge on the
            target geometry. 0 means any color borders will be smoothly blended onto the
            vertices of the target geometry.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - flipUVs : fuv                  (int)           [create,edit]
            Controls how sampled UV data is flipped before being transferred to the target.
            0 means no flipping; 1 means UV data is flipped in the U direction; 2 means UV
            data is flipped in the V direction; and 3 means it is flipped in both
            directions. In conjunction with mirroring, this allows the creation of symmetric
            UV mappings (e.g. the left hand side of the character on one side of the UV map,
            the right hand side on the other).
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - matchChoice : mch              (int)           [create,edit]
            When using topological component matching, selects between possible matches. If
            the meshes involved in the transfer operation have symmetries in their
            topologies, there may be more than one possible topological match. Maya scores
            the possible matches (by comparing the shapes of the meshes) and assigns them an
            index, starting at zero. Match zero, the default, is considered the best, but in
            the event that Maya chooses the wrong one, changing this value will allow the
            user to explore the other matches.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - sampleSpace : spa              (int)           [create,edit]
            Selects which space the attribute transfer is performed in. 0 is world space, 1
            is model space, 4 is component-based, 5 is topology-based. The default is world
            space.
        
        - searchMethod : sm              (int)           [create,edit]
            Specifies which search method to use when correlating points. 0 is closest along
            normal, 3 is closest to point. The default is closest to point.
        
        - searchScaleX : ssx             (float)         [create,edit]
            Specifies an optional scale that should be applied to the x-axis of the target
            model before transferring data. A value of 1.0 (the default) means no scaling; a
            value of -1.0 would indicate mirroring along the x-axis.
        
        - searchScaleY : ssy             (float)         [create,edit]
            Specifies an optional scale that should be applied to the y-axis of the target
            model before transferring data. A value of 1.0 (the default) means no scaling; a
            value of -1.0 would indicate mirroring along the y-axis.
        
        - searchScaleZ : ssz             (float)         [create,edit]
            Specifies an optional scale that should be applied to the z-axis of the target
            model before transferring data. A value of 1.0 (the default) means no scaling; a
            value of -1.0 would indicate mirroring along the z-axis.
        
        - sourceColorSet : scs           (unicode)       [create]
            Specifies the name of a single color set on the source surface(s) that should be
            transferred to the target. This value is only used when the operation is
            configured to transfer a single color set (see the transferColors flag).
        
        - sourceUvSet : suv              (unicode)       [create]
            Specifies the name of a single UV set on the source surface(s) that should be
            transferred to the target. This value is only used when the operation is
            configured to transfer a single UV set (see the transferUVs flag).
        
        - sourceUvSpace : sus            (unicode)       [create]
            Specifies the name of the UV set on the source surface(s) that should be used as
            the transfer space. This value is only used when the operation is configured to
            transfer attributes in UV space.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - targetColorSet : tcs           (unicode)       [create]
            Specifies the name of a single color set on the target surface that should be
            receive the sampled color data. This value is only used when the operation is
            configured to transfer a single color set (see the transferColors flag).
        
        - targetUvSet : tuv              (unicode)       [create]
            Specifies the name of a single UV set on the target surface that should be
            receive the sampled UV data. This value is only used when the operation is
            configured to transfer a single UV set (see the transferUVs flag).
        
        - targetUvSpace : tus            (unicode)       [create]
            Specifies the name of the UV set on the target surface( that should be used as
            the transfer space. This value is only used when the operation is configured to
            transfer attributes in UV space.
        
        - transferColors : col           (int)           [create,edit]
            Controls color set transfer. 0 means no color sets are transferred, 1 means that
            a single color set (specified by sourceColorSet and targetColorSet) is
            transferred, and 2 means that all color sets are transferred.
        
        - transferNormals : nml          (int)           [create,edit]
            A non-zero value indicates vertex normals should be sampled and written into
            user normals on the target surface.
        
        - transferPositions : pos        (int)           [create,edit]
            A non-zero value indicates vertex position should be sampled, causing the target
            surface to wrapto the source surface(s).
        
        - transferUVs : uvs              (int)           [create,edit]
            Controls UV set transfer. 0 means no UV sets are transferred, 1 means that a
            single UV set (specified by sourceUVSet and targetUVSet) is transferred, and 2
            means that all UV sets are transferred.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.transferAttributes`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierLinearWire(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Snow(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class NonLinear(WeightGeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a functional deformer of the specified type that will
        deform the selected objects.  The deformer consists of three nodes: The deformer
        driver that gets connected to the history of the selected objects, the deformer
        handle transform that controls position and orientation of the axis of the
        deformation and the deformer handle that maintains the deformation parameters.
        The type of the deformer handle shape created depends on the specified type of
        the deformer.  The deformer handle will be positioned at the center of the
        selected objects' bounding box and oriented to match the orientation of the
        leading object in the selection list.  The deformer handle transform will be
        selected when the command is completed. The nonLinear command has some flags
        which are specific to the nonLinear type specified with the -type flag. The
        flags correspond to the primary keyable attributes related to the specific type
        of nonLinear node. For example, if the type is bend, then the flags -curvature,
        -lowBoundand -highBoundmay be used to initialize, edit or query those attribute
        values on the bend node. Examples of this are covered in the example section
        below.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - autoParent : ap                (bool)          [create]
            Parents the deformer handle under the selected object's transform. This flag is
            valid only when a single object is selected.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - commonParent : cp              (bool)          [create]
            Creates a new transform and parents the selected object and the deformer handle
            under it.  This flag is valid only when a single object is selected.
        
        - defaultScale : ds              (bool)          [create]
            Sets the scale of the deformation handle to 1.  By default the deformation
            handle is scaled to the match the largest dimension of the selected objects'
            bounding box. [deformerFlags] The attributes of the deformer handle shape can be
            set upon creation, edited and queried as normal flags using either the long or
            the short attribute name.  e.g.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - type : typ                     (unicode)       [create]
            Specifies the type of deformation. The current valid deformation types are:
            bend, twist, squash, flare, sine and wave                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.nonLinear`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMapDel(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapDel`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMapDel`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapDel`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapDel`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapDel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Deletes texture coordinates (UVs) from selected faces.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMapDel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Wood(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class SquareSrf(BoundaryBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMoveUV(PolyModifier):
    def getAxisLen(self, **kwargs):
        """
        AxisLen vector, used to draw the manip handles. Default:1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getAxisLenX(self, **kwargs):
        """
        AxisLen X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getAxisLenY(self, **kwargs):
        """
        AxisLen Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The pivot for scaling and rotation. Default:0.5, 0.5                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getPivotU(self, **kwargs):
        """
        Pivot U coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getPivotV(self, **kwargs):
        """
        Pivot V coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getRandom(self, **kwargs):
        """
        Random value, added to all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getRotationAngle(self, **kwargs):
        """
        Angle of rotation. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getScale(self, **kwargs):
        """
        Scaling vector. Default:1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getScaleU(self, **kwargs):
        """
        Scaling U coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getScaleV(self, **kwargs):
        """
        Scaling V coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getTranslate(self, **kwargs):
        """
        Translation vector. Default:0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getTranslateU(self, **kwargs):
        """
        Translation U coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def getTranslateV(self, **kwargs):
        """
        Translation V coord.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setAxisLen(self, val='True', **kwargs):
        """
        AxisLen vector, used to draw the manip handles. Default:1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setAxisLenX(self, val='True', **kwargs):
        """
        AxisLen X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setAxisLenY(self, val='True', **kwargs):
        """
        AxisLen Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The pivot for scaling and rotation. Default:0.5, 0.5                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setPivotU(self, val='True', **kwargs):
        """
        Pivot U coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setPivotV(self, val='True', **kwargs):
        """
        Pivot V coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setRandom(self, val='True', **kwargs):
        """
        Random value, added to all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setRotationAngle(self, val='True', **kwargs):
        """
        Angle of rotation. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        Scaling vector. Default:1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setScaleU(self, val='True', **kwargs):
        """
        Scaling U coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setScaleV(self, val='True', **kwargs):
        """
        Scaling V coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setTranslate(self, val='True', **kwargs):
        """
        Translation vector. Default:0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setTranslateU(self, val='True', **kwargs):
        """
        Translation U coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    def setTranslateV(self, val='True', **kwargs):
        """
        Translation V coord.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Moves selected UV coordinates in 2D space. As the selected UVs are adjusted, the
        way the image is mapped onto the object changes accordingly. This command
        manipulates the UV values without changing the 3D geometry of the object.
        
        Flags:
        - axisLen : l                    (float, float)  [create,query,edit]
            AxisLen vector, used to draw the manip handles. Default:1.0, 1.0
        
        - axisLenX : lx                  (float)         [create,query,edit]
            AxisLen X coord.
        
        - axisLenY : ly                  (float)         [create,query,edit]
            AxisLen Y coord.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - pivot : pvt                    (float, float)  [create,query,edit]
            The pivot for scaling and rotation. Default:0.5, 0.5
        
        - pivotU : pvu                   (float)         [create,query,edit]
            Pivot U coord.
        
        - pivotV : pvv                   (float)         [create,query,edit]
            Pivot V coord.
        
        - random : ran                   (float)         [create,query,edit]
            Random value, added to all parameters. Default:0.0
        
        - rotationAngle : ra             (float)         [create,query,edit]
            Angle of rotation. Default:0.0
        
        - scale : s                      (float, float)  [create,query,edit]
            Scaling vector. Default:1.0, 1.0
        
        - scaleU : su                    (float)         [create,query,edit]
            Scaling U coord.
        
        - scaleV : sv                    (float)         [create,query,edit]
            Scaling V coord.
        
        - translate : t                  (float, float)  [create,query,edit]
            Translation vector. Default:0.0, 0.0
        
        - translateU : tu                (float)         [create,query,edit]
            Translation U coord.
        
        - translateV : tv                (float)         [create,query,edit]
            Translation V coord.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMoveUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyEditEdgeFlow(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyEditEdgeFlow`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyEditEdgeFlow`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyEditEdgeFlow`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyEditEdgeFlow`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyEditEdgeFlow`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Edit edges of a polygonal object to respect surface curvature.
        
        Flags:
        - adjustEdgeFlow : aef           (float)         [create]
            The weight value of the edge vertices to be positioned. 0: Concave 0:  Middle
            point 1:  Surface continuity 1: Convex Default is 1.0
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - edgeFlow : ef                  (bool)          [create]
            True to enable edge flow. Otherwise, the edge flow is disabled. Default is true.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyEditEdgeFlow`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvBall(TextureEnv):
    __melnode__ = []
    
    
    __readonly__ = {}


class Boundary(BoundaryBase):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def getEndPoint(self, **kwargs):
        """
        True means the curve ends must touch before a surface will be created. Default:false                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def getEndPointTolerance(self, **kwargs):
        """
        Tolerance for end points, only used if endPoint attribute is true. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def getOrder(self, **kwargs):
        """
        True if the curve order is important. Default:true                  Common flags
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def setEndPoint(self, val='True', **kwargs):
        """
        True means the curve ends must touch before a surface will be created. Default:false                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def setEndPointTolerance(self, val='True', **kwargs):
        """
        Tolerance for end points, only used if endPoint attribute is true. Default:0.1                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    def setOrder(self, val='True', **kwargs):
        """
        True if the curve order is important. Default:true                  Common flags
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command produces a boundary surface given 3 or 4 curves. This resulting
        boundary surface passes through two of the given curves in one direction, while
        in the other direction the shape is defined by the remaining curve(s).  If the
        endPointoption is on, then the curve endpoints must touch before a surface will
        be created.   This is the usual situation where a boundary surface is useful.
        Note that there is no tangent continuity option with this command. Unless all
        the curve end points are touching, the resulting surface will not pass through
        all curves.  Instead, use the birail command.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - endPoint : ep                  (bool)          [create,query,edit]
            True means the curve ends must touch before a surface will be created.
            Default:false
        
        - endPointTolerance : ept        (float)         [create,query,edit]
            Tolerance for end points, only used if endPoint attribute is true. Default:0.1
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - order : order                  (bool)          [create,query,edit]
            True if the curve order is important. Default:true                  Common flags
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)
        
        - range : rn                     (bool)          [create]
            Force a curve range on complete input curve.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.boundary`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyNormalPerVertex(PolyModifier):
    def getAllLocked(self, **kwargs):
        """
        Queries if all normals on the selected vertices are locked (frozen) or not                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getDeformable(self, **kwargs):
        """
        DEFAULT  true OBSOLETE flag. This flag will be removed in the next release.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getFreezeNormal(self, **kwargs):
        """
        Specifies that the normal values be frozen (locked) at the current value.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getNormalX(self, **kwargs):
        """
        Specifies the x value normal                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getNormalXYZ(self, **kwargs):
        """
        Specifies the xyz values normal If this flag is used singly, the specified normal xyz values are used for all selected components. If the flag is used multiple times, the number of uses must match the number of selected components, and each use specifies the normal of one component.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getNormalY(self, **kwargs):
        """
        Specifies the y value normal                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getNormalZ(self, **kwargs):
        """
        Specifies the z value normal                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getRelative(self, **kwargs):
        """
        When used, the normal values specified are added relative to the current value.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def getUnFreezeNormal(self, **kwargs):
        """
        Specifies that the normal values that were frozen at the current value be un-frozen (un-locked).                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setAllLocked(self, val='True', **kwargs):
        """
        Queries if all normals on the selected vertices are locked (frozen) or not                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setDeformable(self, val='True', **kwargs):
        """
        DEFAULT  true OBSOLETE flag. This flag will be removed in the next release.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setFreezeNormal(self, val='True', **kwargs):
        """
        Specifies that the normal values be frozen (locked) at the current value.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setNormalX(self, val='True', **kwargs):
        """
        Specifies the x value normal                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setNormalXYZ(self, val='True', **kwargs):
        """
        Specifies the xyz values normal If this flag is used singly, the specified normal xyz values are used for all selected components. If the flag is used multiple times, the number of uses must match the number of selected components, and each use specifies the normal of one component.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setNormalY(self, val='True', **kwargs):
        """
        Specifies the y value normal                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setNormalZ(self, val='True', **kwargs):
        """
        Specifies the z value normal                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setRelative(self, val='True', **kwargs):
        """
        When used, the normal values specified are added relative to the current value.                  
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    def setUnFreezeNormal(self, val='True', **kwargs):
        """
        Specifies that the normal values that were frozen at the current value be un-frozen (un-locked).                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command associates normal(x, y, z) with vertices on polygonal objects. When used
        with the query flag, it returns the normal associated with the specified
        components. However, when queried, the command returns all normals (all vtx-face
        combinations) on the vertex, regardless of whether they are shared or not.
        
        Flags:
        - allLocked : al                 (bool)          [create,query,edit]
            Queries if all normals on the selected vertices are locked (frozen) or not
        
        - deformable : deformable        (bool)          [create,query,edit]
            DEFAULT  true OBSOLETE flag. This flag will be removed in the next release.
        
        - freezeNormal : fn              (bool)          [create,query,edit]
            Specifies that the normal values be frozen (locked) at the current value.
        
        - normalX : x                    (float)         [create,query,edit]
            Specifies the x value normal
        
        - normalXYZ : xyz                (float, float, float) [create,query,edit]
            Specifies the xyz values normal If this flag is used singly, the specified
            normal xyz values are used for all selected components. If the flag is used
            multiple times, the number of uses must match the number of selected components,
            and each use specifies the normal of one component.
        
        - normalY : y                    (float)         [create,query,edit]
            Specifies the y value normal
        
        - normalZ : z                    (float)         [create,query,edit]
            Specifies the z value normal
        
        - relative : rel                 (bool)          [create,query,edit]
            When used, the normal values specified are added relative to the current value.
        
        - unFreezeNormal : ufn           (bool)          [create,query,edit]
            Specifies that the normal values that were frozen at the current value be un-
            frozen (un-locked).                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyNormalPerVertex`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvSphere(TextureEnv):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyRetopo(PolyModifier):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Retopologize a polygonial surface.
        
        Flags:
        - anisotropy : a                 (float)         []
        
        - anisotropyFilter : af          (float)         []
        
        - caching : cch                  (bool)          []
        
        - constructionHistory : ch       (bool)          []
        
        - curveInfluenceDirection : cid  (float)         []
        
        - curveSingularitySeparation : css (float)         []
        
        - frozen : fzn                   (bool)          []
        
        - geodesicRadius : gr            (float)         []
        
        - magnitudeMin : mm              (float)         []
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           []
        
        - resultRefinementLevel : rrl    (int)           []
        
        - resultSmoothing : rs           (bool)          []
        
        - targetEdgeLengthMax : tea      (float)         []
        
        - targetEdgeLengthMin : tem      (float)         []
        
        - targetFaceCount : tfc          (int)           []
        
        
        Derived from mel command `maya.cmds.polyRetopo`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Rock(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class ObjectSet(Entity):
    """
    The ObjectSet class and `SelectionSet` class work together.  Both classes have a very similar interface,
    the primary difference is that the ObjectSet class represents connections to an objectSet node, while the
    `SelectionSet` class is a generic set, akin to pythons built-in `set`.
    
    
    create some sets:
    
        >>> from pymel.core import *
        >>> f=newFile(f=1) #start clean
        >>>
        >>> s = sets()  # create an empty set
        >>> s.union( ls( type='camera') )  # add some cameras to it
        >>> s.members()  # doctest: +SKIP
        [nt.Camera(u'sideShape'), nt.Camera(u'frontShape'), nt.Camera(u'topShape'), nt.Camera(u'perspShape')]
        >>> sel = s.asSelectionSet() # or as a SelectionSet
        >>> sel # doctest: +SKIP
        nt.SelectionSet([u'sideShape', u'frontShape', u'topShape', u'perspShape'])
        >>> sorted(sel) # as a sorted list
        [nt.Camera(u'frontShape'), nt.Camera(u'perspShape'), nt.Camera(u'sideShape'), nt.Camera(u'topShape')]
    
    Operations between sets result in `SelectionSet` objects:
    
        >>> t = sets()  # create another set
        >>> t.add( 'perspShape' )  # add the persp camera shape to it
        >>> s.getIntersection(t)
        nt.SelectionSet([u'perspShape'])
        >>> diff = s.getDifference(t)
        >>> diff #doctest: +SKIP
        nt.SelectionSet([u'sideShape', u'frontShape', u'topShape'])
        >>> sorted(diff)
        [nt.Camera(u'frontShape'), nt.Camera(u'sideShape'), nt.Camera(u'topShape')]
        >>> s.isSuperSet(t)
        True
    """
    
    
    
    def __and__(self, s):
        """
        operator for `ObjectSet.getIntersection`
        """
        pass
    def __contains__(self, item):
        """
        Returns
        -------
        bool
        """
        pass
    def __getitem__(self, index): pass
    def __iand__(self, s):
        """
        operator for `ObjectSet.intersection`
        """
        pass
    def __ior__(self, s):
        """
        operator for `ObjectSet.union`
        """
        pass
    def __isub__(self, s):
        """
        operator for `ObjectSet.difference`
        """
        pass
    def __ixor__(self, s):
        """
        operator for `ObjectSet.symmetricDifference`
        """
        pass
    def __len__(self):
        """
        Returns
        -------
        int
        """
        pass
    def __or__(self, s):
        """
        operator for `ObjectSet.getUnion`
        """
        pass
    def __sub__(self, s):
        """
        operator for `ObjectSet.getDifference`
        """
        pass
    def __xor__(self, s):
        """
        operator for `ObjectSet.symmetricDifference`
        """
        pass
    def add(self, item): pass
    def addMember(self, item): pass
    def addMembers(self, list):
        """
        Add a list of new objects to the set.
        
        Parameters:
        list : 'SelectionSet'
            the list of objects as a selection list
        
        Derived from api method `maya.OpenMaya.MFnSet.addMembers`
        """
        pass
    def asSelectionSet(self, flatten='False'):
        """
        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.
        
        Parameters:
        flatten : 'bool'
            whether to flatten the returned list.
        
        
        Returns:
        'SelectionSet'
        
        Derived from api method `maya.OpenMaya.MFnSet.getMembers`
        """
        pass
    def clear(self):
        """
        Removes all elements from this set
        Derived from api method `maya.OpenMaya.MFnSet.clear`
        """
        pass
    def difference(self, other): pass
    def elements(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use ObjectSet.members instead
        
        
        return members as a list
        
        Returns
        -------
        List[general.PyNode]
        """
        pass
    def flattened(self):
        """
        return a flattened list of members.
        
        equivalent to `ObjectSet.members(flatten=True)`
        
        Returns
        -------
        List[general.PyNode]
        """
        pass
    def forceElement(self, member):
        """
        Forces addition of the items to the set. If the items are in
        another set which is in the same partition as the given set,
        the items will be removed from the other set in order to keep the
        sets in the partition mutually exclusive with respect to membership.
        """
        pass
    def getAnnotation(self):
        """
        Returns the annotation string for this set. This allows a description of the set to be stored with it.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnSet.annotation`
        """
        pass
    def getDifference(self, other):
        """
        Parameters
        ----------
        other : Union[str, ObjectSet]
        
        Returns
        -------
        SelectionSet
        """
        pass
    def getIntersection(self, other):
        """
        Parameters
        ----------
        other : Union[str, ObjectSet]
        
        Returns
        -------
        SelectionSet
        """
        pass
    def getSymmetricDifference(self, other):
        """
        also known as XOR
        
        Parameters
        ----------
        other : Union[str, ObjectSet]
        
        Returns
        -------
        SelectionSet
        """
        pass
    def getUnion(self, other):
        """
        Parameters
        ----------
        other : Union[str, ObjectSet]
        
        Returns
        -------
        SelectionSet
        """
        pass
    def hasRestrictions(self):
        """
        Returns true if this function set has restrictions on the type of objects that it may contain.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnSet.hasRestrictions`
        """
        pass
    def intersection(self, other): pass
    def intersectsWith(self, otherSet):
        """
        Returns true if this set intersects with the given set. An intersection occurs if there are any common members between the two sets.
        
        Parameters:
        otherSet : 'PyNode'
            set to test for intersection with
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnSet.intersectsWith`
        """
        pass
    def isEqual(self, other):
        """
        do not use __eq__ to test equality of set contents. __eq__ will only tell you if
        the passed object is the same node, not if this set and the passed set
        have the same contents.
        
        Parameters
        ----------
        other : Union[str, ObjectSet]
        
        Returns
        -------
        bool
        """
        pass
    def isMember(self, object):
        """
        Returns true if the given object (dependency node) is a member of this set
        
        Parameters:
        object : 'PyNode'
            object to test for membership
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnSet.isMember`
        """
        pass
    def isRenderable(self):
        """
        Mimics cmds.sets(self, q=True, renderable=True).
        
        Alternatively you can use isinstance(someset, pm.nt.ShadingEngine)
        since shadingEngine is the only renderable set in maya now
        """
        pass
    def isSubSet(self, other):
        """
        Parameters
        ----------
        other : Union[str, ObjectSet]
        
        Returns
        -------
        bool
        """
        pass
    def isSuperSet(self, other):
        """
        Parameters
        ----------
        other : Union[str, ObjectSet]
        
        Returns
        -------
        bool
        """
        pass
    def members(self, flatten='False'):
        """
        return members as a list
        
        Returns
        -------
        List[general.PyNode]
        """
        pass
    def remove(self, item): pass
    def removeMember(self, item): pass
    def removeMembers(self, list):
        """
        Remove items of the selection list from the set.
        
        Parameters:
        list : 'SelectionSet'
            the selection list of items to remove
        
        Derived from api method `maya.OpenMaya.MFnSet.removeMembers`
        """
        pass
    def resetTo(self, newContents):
        """
        clear and set the members to the passed list/set
        """
        pass
    def restriction(self):
        """
        Returns the type of membership restriction that this set has.
        
        Returns:
        'ObjectSet.Restriction'
        
        Derived from api method `maya.OpenMaya.MFnSet.restriction`
        """
        pass
    def setAnnotation(self, annotation):
        """
        Sets the annotation string for this set. This allows a description of the set to be stored with it.
        
        Parameters:
        annotation : 'unicode'
            new annotation string
        
        Derived from api method `maya.OpenMaya.MFnSet.setAnnotation`
        """
        pass
    def symmetricDifference(self, other): pass
    def union(self, other): pass
    Restriction = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Id(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Wire(WeightGeometryFilter):
    def addGeometry(self, object):
        """
        Adds a piece of geometry to the deformation.
        
        Parameters:
        object : 'PyNode'
            the geometry
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.addGeometry`
        """
        pass
    def addWire(self, object):
        """
        Adds a new wire curve to the deformation.
        
        Parameters:
        object : 'PyNode'
            the new wire
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.addWire`
        """
        pass
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getAffectedGeometry(self):
        """
        The geometry affected by this deformer is packed into the provided list of MObjects. Each of the MObjects will be a DAG node that has geometry.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.getAffectedGeometry`
        """
        pass
    def getCrossingEffect(self):
        """
        Returns the crossing effect for this wire deformer.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.crossingEffect`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getDropoffDistance(self, **kwargs):
        """
        Set the dropoff distance (second parameter) for the wire at index (first parameter).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getEnvelope(self):
        """
        Returns the envelope for this deformer.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.envelope`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getHolder(self, **kwargs):
        """
        Set the specified curve or surface (second parameter  as a holder for the wire at index (first parameter).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getHoldingShape(self, wireIndex):
        """
        Returns the holding shape for the given wire. The holding shape may be a nurbs curve or a nurbs surface. If the given wire does not have a holding shape, then a null MObject handle will be returned.
        
        Parameters:
        wireIndex : 'int'
            index of wire to get the holding shape for
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.holdingShape`
        """
        pass
    def getLocalInfluence(self, **kwargs):
        """
        Set the local control a wire has with respect to other wires irrespective of whether it is deforming the surface. Varies from no local effect at 0 to full local control at 1. Default is 0.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getLocalIntensity(self):
        """
        Returns the local intensity for this wire deformer.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.localIntensity`
        """
        pass
    def getRotation(self):
        """
        Returns the rotation value for this deformer.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.rotation`
        """
        pass
    def getWire(self, **kwargs):
        """
        Specify or query the wire curve name.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getWireCount(self, **kwargs):
        """
        Set the number of wires.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def getWireDropOffDistance(self, wireIndex):
        """
        Return the drop off distance of the wire at the given index. Increasing this value will give the wire a greater area of influence.
        
        Parameters:
        wireIndex : 'int'
            index of wire to return the drop off distance for
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.wireDropOffDistance`
        """
        pass
    def getWireScale(self, wireIndex):
        """
        Return the radial scale of the wire at the given index. The scale value affects how the wire modifies the geometry in its area of influence. A value of between 0.0 and 1.0 causes the wire to pull the surrounding geometry points towards itself. A value of greater than one causes the wire to repulse the geometry points around it. A value of exactly 1.0 causes the wire to neither pull nor push the points around it.
        
        Parameters:
        wireIndex : 'int'
            index of wire to return the scale value for
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.wireScale`
        """
        pass
    def numDropoffLocators(self, wireIndex):
        """
        Returns the number of drop off locators.
        
        Parameters:
        wireIndex : 'int'
            the index of the wire curve to query
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.numDropoffLocators`
        """
        pass
    def numWires(self):
        """
        returns the number of wire curves connected to this deformer.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.numWires`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def removeGeometry(self, object):
        """
        Removes a piece of geometry from the deformation.
        
        Parameters:
        object : 'PyNode'
            the geometry
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.removeGeometry`
        """
        pass
    def setCrossingEffect(self, crossingEffect):
        """
        Sets the crossing effect for this wire deformer.
        
        Parameters:
        crossingEffect : 'float'
            New crossing effect value
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.setCrossingEffect`
        """
        pass
    def setDropoffDistance(self, val='True', **kwargs):
        """
        Set the dropoff distance (second parameter) for the wire at index (first parameter).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def setEnvelope(self, envelope):
        """
        Sets the envelope for this deformer.
        
        Parameters:
        envelope : 'float'
            envelope value
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.setEnvelope`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def setHolder(self, val='True', **kwargs):
        """
        Set the specified curve or surface (second parameter  as a holder for the wire at index (first parameter).                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def setHoldingShape(self, wireIndex, holdingShape):
        """
        Sets the holding shape for the given wire. The holding shape may be a nurbs curve or a nurbs surface.
        
        Parameters:
        wireIndex : 'int'
            index of wire to set the holding shape for
        holdingShape : 'PyNode'
            nurbs curve or surface to use as holding shape
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.setHoldingShape`
        """
        pass
    def setLocalInfluence(self, val='True', **kwargs):
        """
        Set the local control a wire has with respect to other wires irrespective of whether it is deforming the surface. Varies from no local effect at 0 to full local control at 1. Default is 0.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def setLocalIntensity(self, localIntensity):
        """
        Sets the local intensity for this wire deformer.
        
        Parameters:
        localIntensity : 'float'
            New local intensity value
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.setLocalIntensity`
        """
        pass
    def setRotation(self, rotation):
        """
        Sets the rotation value for this deformer.
        
        Parameters:
        rotation : 'float'
            new rotation value
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.setRotation`
        """
        pass
    def setWire(self, val='True', **kwargs):
        """
        Specify or query the wire curve name.                  
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def setWireCount(self, val='True', **kwargs):
        """
        Set the number of wires.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    def setWireDropOffDistance(self, wireIndex, dropOff):
        """
        Sets the drop off distance of the wire at the given index. Increasing this value will give the wire a greater area of influence.
        
        Parameters:
        wireIndex : 'int'
            index of wire to set the drop off distance for
        dropOff : 'float'
            new drop off value
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.setWireDropOffDistance`
        """
        pass
    def setWireScale(self, wireIndex, scale):
        """
        Sets the radial scale value of the wire at the given index. The scale value affects how the wire modifies the geometry in its area of influence. A value of between 0.0 and 1.0 causes the wire to pull the surrounding geometry points towards itself. A value of greater than one causes the wire to repulse the geometry points around it. A value of exactly 1.0 causes the wire to neither pull nor push the points around it.
        
        Parameters:
        wireIndex : 'int'
            index of wire to set the drop off distance for
        scale : 'float'
            new scale value
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.setWireScale`
        """
        pass
    def wire(self, wireIndex):
        """
        Return the wire at the given index. The returned object will be a nurbs curve shape suitable for use with the MFnNurbsCurve function set.
        
        Parameters:
        wireIndex : 'int'
            index of wire to return
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnWireDeformer.wire`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a wire deformer. In the create mode the selection list is
        treated as the object(s) to be deformed, Wires are specified with the -w flag.
        Each wire can optionally have a holder which helps define the the regon of the
        object that is affected by the deformer.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - crossingEffect : ce            (float)         [create,query,edit]
            Set the amount of convolution effect. Varies from fully convolved at 0 to a
            simple additive effect at 1 (which is what you get with the filter off). Default
            is 0. This filter should make its way into all blend nodes that deal with
            combining effects from multiple sources.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - dropoffDistance : dds          (int, float)    [create,query,edit]
            Set the dropoff distance (second parameter) for the wire at index (first
            parameter).
        
        - envelope : en                  (float)         [create,query,edit]
            Set the envelope value for the deformer. Default is 1.0
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - groupWithBase : gw             (bool)          [create]
            Groups the wire with the base wire so that they can easily be moved together to
            create a ripple effect. Default is false.
        
        - holder : ho                    (int, unicode)  [create,query,edit]
            Set the specified curve or surface (second parameter  as a holder for the wire
            at index (first parameter).
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - localInfluence : li            (float)         [create,query,edit]
            Set the local control a wire has with respect to other wires irrespective of
            whether it is deforming the surface. Varies from no local effect at 0 to full
            local control at 1. Default is 0.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - wire : w                       (unicode)       [create,query,edit]
            Specify or query the wire curve name.
        
        - wireCount : wc                 (int)           [create,query,edit]
            Set the number of wires.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.wire`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Blend(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Maths(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Jiggle(WeightGeometryFilter):
    __melnode__ = []
    
    
    __readonly__ = {}


class THhardwareShader(HwShader):
    __melnode__ = []
    
    
    __readonly__ = {}


class THskinCluster(SkinCluster):
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvSky(TextureEnv):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Distribute(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ChildNode(ListItem):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_PfxConnect(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Explode(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyModifierWorld(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class Marble(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderSetupLayer(ListItem):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SolidFractal(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class IkSpringSolver(THikSolverNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THclientDevice(ClientDevice):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SoftMod(WeightGeometryFilter):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def getWeightedNode(self, **kwargs):
        """
        Transform node in the DAG above the softMod to which all percents are applied. The second node specifies the descendent of the first node from where the transformation matrix is evaluated. Default is the softMod handle.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def resetGeometry(self, val='True', **kwargs):
        """
        Reset the geometry matrices for the objects being deformed by the softMod. This flag is used to get rid of undesirable effects that happen if you scale an object that is deformed by a softMod.                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    def setWeightedNode(self, val='True', **kwargs):
        """
        Transform node in the DAG above the softMod to which all percents are applied. The second node specifies the descendent of the first node from where the transformation matrix is evaluated. Default is the softMod handle.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The softMod command creates a softMod or edits the membership of an existing
        softMod. The command returns the name of the softMod node upon creation of a new
        softMod.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - bindState : bs                 (bool)          [create]
            Specifying this flag adds in a compensation to ensure the softModed objects
            preserve their spatial position when softModed. This is required to prevent the
            geometry from jumping at the time the softMod is created in situations when the
            softMod transforms at softMod time are not identity.
        
        - curveInterpolation : ci        (int)           [create]
            Ramp interpolation corresponding to the specified curvePoint position. Integer
            values of 0-3 are valid, corresponding to none, linear, smoothand
            splinerespectively. This flag may only be used in conjunction with the
            curvePoint and curveValue flag.
        
        - curvePoint : cp                (float)         [create]
            Position of ramp value on normalized 0-1 scale. This flag may only be used in
            conjunction with the curveInterpolation and curveValue flags.
        
        - curveValue : cv                (float)         [create]
            Ramp value corresponding to the specified curvePoint position. This flag may
            only be used in conjunction with the curveInterpolation and curvePoint flags.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - envelope : en                  (float)         [create,query,edit]
            Set the envelope value for the deformer. Default is 1.0
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - falloffAroundSelection : fas   (bool)          [create]
            Falloff will be calculated around any selected components
        
        - falloffBasedOnX : fbx          (bool)          [create]
            Falloff will be calculated using the X component.
        
        - falloffBasedOnY : fby          (bool)          [create]
            Falloff will be calculated using the Y component.
        
        - falloffBasedOnZ : fbz          (bool)          [create]
            Falloff will be calculated using the Z component.
        
        - falloffCenter : fc             (float, float, float) [create]
            Set the falloff center point of the softMod.
        
        - falloffMasking : fm            (bool)          [create]
            Deformation will be restricted to selected components
        
        - falloffMode : fom              (int)           [create]
            Set the falloff method used for the softMod.
        
        - falloffRadius : fr             (float)         [create]
            Set the falloff radius of the softMod.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - relative : rel                 (bool)          [create]
            Enable relative mode for the softMod. In relative mode, Only the transformations
            directly above the softMod are used by the softMod. Default is off.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - resetGeometry : rg             (bool)          [edit]
            Reset the geometry matrices for the objects being deformed by the softMod. This
            flag is used to get rid of undesirable effects that happen if you scale an
            object that is deformed by a softMod.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).
        
        - weightedNode : wn              (unicode, unicode) [create,query,edit]
            Transform node in the DAG above the softMod to which all percents are applied.
            The second node specifies the descendent of the first node from where the
            transformation matrix is evaluated. Default is the softMod handle.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.softMod`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class VolumeNoise(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Influence(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvChrome(TextureEnv):
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdAddTopology(SubdModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Constraint(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Spring(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THblendShape(BlendShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromSubdiv(CurveRange):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Transform(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeThreePointCircularArc(MakeCircularArc):
    __melnode__ = []
    
    
    __readonly__ = {}


class Partition(Entity):
    def addMember(self, set):
        """
        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.
        
        Parameters:
        set : 'PyNode'
            new set to be added to this partiton.
        
        Derived from api method `maya.OpenMaya.MFnPartition.addMember`
        """
        pass
    def getRender(self, **kwargs):
        """
        New partition can contain render sets. For use in creation mode only. Default is false.  Can also be used with query flag - returns boolean.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.partition`
        """
        pass
    def isRenderPartition(self):
        """
        Returns true if this partition is a render partition.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnPartition.isRenderPartition`
        """
        pass
    def removeMember(self, set):
        """
        Remove a set from this partition.
        
        Parameters:
        set : 'PyNode'
            old set to be removed from this partiton.
        
        Derived from api method `maya.OpenMaya.MFnPartition.removeMember`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create, query or add/remove sets to a partition. If a
        partition name needs to be specified, it is the first argument, other arguments
        represent the set names. Without any flags, the command will create a partition
        with a default name.  Any sets which are arguments to the command will be added
        to the partition. A set can be added to a partition only if none of its members
        are in any of the other sets in the partition. If the -re/render flag is
        specified when the partition is created, only 'renderable' sets can be added to
        the partition. Sets can be added and removed from a partition by using the
        -addSet or -removeSet flags. Note:If a set is already selected, and the
        partition command is executed, the set will be added to the created partition.
        
        Flags:
        - addSet : add                   (PyNode)        [create]
            Adds the list of sets to the named partition.
        
        - name : n                       (unicode)       [create]
            Assigns the given name to new partition. Valid only for create mode.
        
        - removeSet : rm                 (PyNode)        [create]
            Removes the list of sets from the named partition.
        
        - render : re                    (bool)          [create,query]
            New partition can contain render sets. For use in creation mode only. Default is
            false.  Can also be used with query flag - returns boolean.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.partition`
        """
        pass
    Restriction = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Ffd(WeightGeometryFilter):
    def addGeometry(self, object):
        """
        Adds a piece of geometry to the deformation.
        
        Parameters:
        object : 'PyNode'
            the geometry
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.addGeometry`
        """
        pass
    def baseLattice(self):
        """
        This returns the base version of the lattice that describes the region of space deformed by the lattice. The returned base lattice is a shape in the DAG and can be accessed using the MFnDagNode function set.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.baseLattice`
        """
        pass
    def deformLattice(self):
        """
        This returns the deformed version of the lattice. The deformed lattice is a shape in the DAG and should be modified using the MFnLattice function set.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.deformLattice`
        """
        pass
    def getAffectedGeometry(self):
        """
        The geometry affected by this deformer is packed into the provided list of MObjects. Each of the MObjects will be a DAG node that has geometry.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.getAffectedGeometry`
        """
        pass
    def getDivisions(self):
        """
        Retrieve the number of divisions in each of the X, Y, and Z directions. The number of divisions specifies the resolution of the lattice.
        
        Returns:
        Tuple['int', 'int', 'int']
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.getDivisions`
        """
        pass
    def removeGeometry(self, object):
        """
        Removes a piece of geometry from the deformation.
        
        Parameters:
        object : 'PyNode'
            the geometry
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.removeGeometry`
        """
        pass
    def resetLattice(self, centerLattice='False'):
        """
        This method resets the deformed lattice to match the base lattice.
        
        Parameters:
        centerLattice : 'bool'
            whether to center the lattice
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.resetLattice`
        """
        pass
    def setDivisions(self, x, y, z):
        """
        Set the number of divisions in each of the X, Y, and Z directions. The number of divisions specifies the resolution of the lattice.
        
        Parameters:
        x : 'int'
            number of divisions in the X direction
        y : 'int'
            number of divisions in the Y direction
        z : 'int'
            number of divisions in the Z direction
        
        Derived from api method `maya.OpenMayaAnim.MFnLatticeDeformer.setDivisions`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmSplineCache(XgmModifierBase):
    """
    class counterpart of mel function `xgmSplineCache`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - create : cr                    (bool)          []
        
        - export : ex                    (bool)          []
        
        - file : f                       (unicode)       []
        
        - fitTimeRange : ftr             (bool)          []
        
        - im : im                        (bool)          []
        
        - jobArg : j                     (unicode)       []
        
        - replace : rp                   (bool)          []
        
        - setToStartFrame : sts          (bool)          []
        
        
        Derived from mel command `maya.cmds.xgmSplineCache`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Ik2Bsolver(THikSolverNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeTwoPointCircularArc(MakeCircularArc):
    __melnode__ = []
    
    
    __readonly__ = {}


class ResultCurveTimeToAngular(ResultCurve):
    def addKey(self, time, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        time : 'Time'
            Time at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Symmetry(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TripleShadingSwitch(BaseShadingSwitch):
    __melnode__ = []
    
    
    __readonly__ = {}


class ResultCurveTimeToLinear(ResultCurve):
    def addKey(self, time, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        time : 'Time'
            Time at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPrimitive(PolyCreator):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the primitive polygon. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize Each Face Separately3: Normalize Collectively4: Normalize and Preserve Aspect Ratio
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getRadius(self, **kwargs):
        """
        This flag specifies the radius of the primitive polygon. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getSideLength(self, **kwargs):
        """
        This flag specifies the side length of primitive polygon. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def getTexture(self, **kwargs):
        """
        What texture mechanism to be applied 0=No textures, 1=Object, 2=Faces                  Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the primitive polygon. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize Each Face Separately3: Normalize Collectively4: Normalize and Preserve Aspect Ratio
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        This flag specifies the radius of the primitive polygon. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setSideLength(self, val='True', **kwargs):
        """
        This flag specifies the side length of primitive polygon. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        What texture mechanism to be applied 0=No textures, 1=Object, 2=Faces                  Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a polygon primative
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the primitive polygon. Q:
            When queried, this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create,query,edit]
            Create UVs or not. 0: No UVs1: No Normalization2: Normalize Each Face
            Separately3: Normalize Collectively4: Normalize and Preserve Aspect Ratio
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        - polyType : pt                  (int)           [create]
            This flag allows a specific primitive poly to be selected for creation of mesh,
            The valid values is 0 0 implies soccer ball to be created. C: Default is 0
        
        - radius : r                     (float)         [create,query,edit]
            This flag specifies the radius of the primitive polygon. C: Default is 1.0. Q:
            When queried, this flag returns a float.
        
        - sideLength : l                 (float)         [create,query,edit]
            This flag specifies the side length of primitive polygon. C: Default is 1.0. Q:
            When queried, this flag returns a float.
        
        - texture : tx                   (int)           [create,query,edit]
            What texture mechanism to be applied 0=No textures, 1=Object, 2=Faces
            Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polyPrimitive`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ResultCurveTimeToTime(ResultCurve):
    def addKey(self, timeInput, timeValue, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given output time value and tangent types at the specified input time for curves of type kAnimCurveTT.
        
        Parameters:
        timeInput : 'Time'
            Time at which the key is to be added
        timeValue : 'Time'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTT at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'Time'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class Reflect(Lambert):
    def getReflectedColor(self):
        """
        Retrieves the value of the "reflectedColor" attribute of a reflective shader node. This attribute represents the color of reflection produced by the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.reflectedColor`
        """
        pass
    def getReflectedRayDepthLimit(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.reflectedRayDepthLimit`
        """
        pass
    def getReflectivity(self):
        """
        Retrieves the value of the "reflectivity" attribute of a reflective shader node. This attribute represents the reflectivity of the shader.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.reflectivity`
        """
        pass
    def getSpecularColor(self):
        """
        Retrieves the value of the "specularColor" attribute of a reflective shader node. This attribute represents the color of specular highlights produced by the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.specularColor`
        """
        pass
    def setReflectedColor(self, reflected_color):
        """
        Sets the value of the "reflectedColor" attribute of a shader node.
        
        Parameters:
        reflected_color : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.setReflectedColor`
        """
        pass
    def setReflectedRayDepthLimit(self, reflected_ray_depth_limit):
        """
        Sets the value of the "reflectedRayDepthLimit" attribute of a lambert shader node.
        
        Parameters:
        reflected_ray_depth_limit : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.setReflectedRayDepthLimit`
        """
        pass
    def setReflectivity(self, reflect):
        """
        Sets the value of the "reflectivity" attribute of a shader node.
        
        Parameters:
        reflect : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.setReflectivity`
        """
        pass
    def setSpecularColor(self, specular_color):
        """
        Sets the value of the "specularColor" attribute of a shader node.
        
        Parameters:
        specular_color : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnReflectShader.setSpecularColor`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ArnoldAOVChildSelector(Selector):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ResultCurveTimeToUnitless(ResultCurve):
    def addKey(self, time, value, tangentInType="'global_'", tangentOutType="'global_'"):
        """
        Adds a new key with the given value and tangent types at the specified time for curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU.
        
        Parameters:
        time : 'Time'
            Time at which the key is to be added
        value : 'float'
            Value to which the key is to be set
        tangentInType : 'AnimCurve.TangentType'
            In tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        tangentOutType : 'AnimCurve.TangentType'
            Out tangent type for the key
        
            values: 'global_', 'fixed', 'linear', 'flat', 'smooth', 'step', 'slow', 'fast', 'clamped', 'plateau', 'stepNext', 'auto', 'shared1', 'shared2', 'shared3', 'shared4', 'shared5', 'shared6', 'shared7', 'shared8', 'customStart', 'customEnd', 'typeCount'
        change : 'MAnimCurveChange'
            Optional cache to store undo/redo information.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.addKey`
        """
        pass
    def evaluate(self, atTime):
        """
        Determines the interpolated output value of Anim Curves of type kAnimCurveTA, kAnimCurveTL and kAnimCurveTU at the specified time.
        
        Parameters:
        atTime : 'Time'
            Time at which the Anim Curve is to be evaluated
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.evaluate`
        """
        pass
    def findClosest(self, time):
        """
        Determines the index of the key which is set at the time closest to the specified time.
        
        Parameters:
        time : 'Time'
            Time for which a key index is required
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnAnimCurve.findClosest`
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierScale(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Trig(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Visibility(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierClump(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ParentTessellate(AbstractBaseNurbsConversion):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Audio(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HierarchyTestNode3(HierarchyTestNode2):
    __melnode__ = []
    
    
    __readonly__ = {}


class NurbsToSubdiv(AbstractBaseNurbsConversion):
    def getAddUnderTransform(self, **kwargs):
        """
        Specify whether the new surface should be added under the old transform or not.                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def getCollapsePoles(self, **kwargs):
        """
        Collapse poles into a single point Default:false                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def getMatchPeriodic(self, **kwargs):
        """
        Match periodic surface texture mapping in the result. Default:false                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def getMaxPolyCount(self, **kwargs):
        """
        The maximum number of base mesh faces in the resulting subdivision surface. Default:1000                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def getReverseNormal(self, **kwargs):
        """
        Reverse the NURBS surface normal in the conversion. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def setAddUnderTransform(self, val='True', **kwargs):
        """
        Specify whether the new surface should be added under the old transform or not.                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def setCollapsePoles(self, val='True', **kwargs):
        """
        Collapse poles into a single point Default:false                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def setMatchPeriodic(self, val='True', **kwargs):
        """
        Match periodic surface texture mapping in the result. Default:false                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def setMaxPolyCount(self, val='True', **kwargs):
        """
        The maximum number of base mesh faces in the resulting subdivision surface. Default:1000                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    def setReverseNormal(self, val='True', **kwargs):
        """
        Reverse the NURBS surface normal in the conversion. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command converts a NURBS surface and produces a subd surface. The name of
        the new subdivision surface is returned. If construction history is ON, then the
        name of the new dependency node is returned as well.
        
        Flags:
        - addUnderTransform : aut        (bool)          [create,query,edit]
            Specify whether the new surface should be added under the old transform or not.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - collapsePoles : cp             (bool)          [create,query,edit]
            Collapse poles into a single point Default:false
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - matchPeriodic : mp             (bool)          [create,query,edit]
            Match periodic surface texture mapping in the result. Default:false
        
        - maxPolyCount : mpc             (int)           [create,query,edit]
            The maximum number of base mesh faces in the resulting subdivision surface.
            Default:1000
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - reverseNormal : rn             (bool)          [create,query,edit]
            Reverse the NURBS surface normal in the conversion. Default:true
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.nurbsToSubdiv`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Delay(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Collection(ListItem):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Cloth(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyUnite(PolyCreator):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyUnite`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.polyUnite`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyUnite`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.polyUnite`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a new poly as an union of a list of polys If no objects are
        specified in the command line, then the objects from the active list are used.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - centerPivot : cp               (bool)          [create]
            Set the resulting object's pivot to the center of the selected objects bounding
            box.
        
        - constructionHistory : ch       (bool)          []
        
        - frozen : fzn                   (bool)          []
        
        - mergeUVSets : muv              (int)           [create]
            Specify how UV sets will be merged on the output mesh. The choices are 0 | 1 |
            2. 0 = Do not merge. Each UV set on each mesh will become a new UV set in the
            output. 1 = Merge by name. UV sets with the same name will be merged. 2 = Merge
            by UV links. UV sets will be merged so that UV linking on the input meshes
            continues to work. The default is 1 (merge by name).
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - object : o                     (bool)          []
        
        - objectPivot : op               (bool)          [create]
            Set the resulting object's pivot to last selected object's pivot.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyUnite`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Bulge(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbCube(Primitive):
    def getAxis(self, **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface. 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getHeightRatio(self, **kwargs):
        """
        Ratio of heightto widthDefault:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getLengthRatio(self, **kwargs):
        """
        Ratio of lengthto widthDefault:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getPatchesU(self, **kwargs):
        """
        Number of sections in U Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getPatchesV(self, **kwargs):
        """
        Number of sections in V Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def getWidth(self, **kwargs):
        """
        Width of the object Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface. 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setHeightRatio(self, val='True', **kwargs):
        """
        Ratio of heightto widthDefault:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setLengthRatio(self, val='True', **kwargs):
        """
        Ratio of lengthto widthDefault:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setPatchesU(self, val='True', **kwargs):
        """
        Number of sections in U Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setPatchesV(self, val='True', **kwargs):
        """
        Number of sections in V Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        Width of the object Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The nurbsCube command creates a new NURBS Cube made up of six planes. It creates
        an unit cube with center at origin by default.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            The primitive's axis
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface. 1 - linear, 2 - quadratic, 3 - cubic, 5 -
            quintic, 7 - heptic Default:3
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - heightRatio : hr               (float)         [create,query,edit]
            Ratio of heightto widthDefault:1.0
        
        - lengthRatio : lr               (float)         [create,query,edit]
            Ratio of lengthto widthDefault:1.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - patchesU : u                   (int)           [create,query,edit]
            Number of sections in U Default:1
        
        - patchesV : v                   (int)           [create,query,edit]
            Number of sections in V Default:1
        
        - pivot : p                      (float, float, float) [create,query,edit]
            The primitive's pivot point
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        - width : w                      (float)         [create,query,edit]
            Width of the object Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsCube`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'nurbsCube'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class File(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbPlane(Primitive):
    def getAxis(self, **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getLengthRatio(self, **kwargs):
        """
        The ratio of lengthto widthof the plane. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getPatchesU(self, **kwargs):
        """
        The number of spans in the U direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getPatchesV(self, **kwargs):
        """
        The number of spans in the V direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the plane Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setLengthRatio(self, val='True', **kwargs):
        """
        The ratio of lengthto widthof the plane. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setPatchesU(self, val='True', **kwargs):
        """
        The number of spans in the U direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setPatchesV(self, val='True', **kwargs):
        """
        The number of spans in the V direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the plane Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The nurbsPlane command creates a new NURBS Plane and return the name of the new
        surface. It creates an unit plane with center at origin by default.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            The primitive's axis
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface 1 - linear, 2 - quadratic, 3 - cubic, 5 -
            quintic, 7 - heptic Default:3
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - lengthRatio : lr               (float)         [create,query,edit]
            The ratio of lengthto widthof the plane. Default:1.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - patchesU : u                   (int)           [create,query,edit]
            The number of spans in the U direction. Default:1
        
        - patchesV : v                   (int)           [create,query,edit]
            The number of spans in the V direction. Default:1
        
        - pivot : p                      (float, float, float) [create,query,edit]
            The primitive's pivot point
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        - width : w                      (float)         [create,query,edit]
            The width of the plane Default:1.0                  Common flags
        
        
        Derived from mel command `maya.cmds.nurbsPlane`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'nurbsPlane'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RevolvedPrimitive(Primitive):
    __melnode__ = []
    
    
    __readonly__ = {}


class BlendColorSets(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Replicator(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdTweakUV(SubdModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCloseBorder(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCloseBorder`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCloseBorder`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCloseBorder`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCloseBorder`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCloseBorder`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Closes open borders of objects. For each border edge given, a face is created to
        fill the hole the edge lies on.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCloseBorder`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Fractal(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdTweak(SubdModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyAppend(PolyModifier):
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyAppend`
        """
        pass
    def getSubdivision(self, **kwargs):
        """
        This flag specifies the level of subdivisions. Automatically subdivides new edges into the given number of edges. Existing edges cannot be subdivided. C : Default is 1 (no subdivision). Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyAppend`
        """
        pass
    def getTexture(self, **kwargs):
        """
        Specifies how new faces are mapped. 0 - None; 1 - Normalize; 2 - Unitize C: Default is 0 (no mapping). Q: When queried, this flag returns an intFlag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyAppend`
        """
        pass
    def setSubdivision(self, val='True', **kwargs):
        """
        This flag specifies the level of subdivisions. Automatically subdivides new edges into the given number of edges. Existing edges cannot be subdivided. C : Default is 1 (no subdivision). Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyAppend`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        Specifies how new faces are mapped. 0 - None; 1 - Normalize; 2 - Unitize C: Default is 0 (no mapping). Q: When queried, this flag returns an intFlag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyAppend`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Appends a new face to the selected polygonal object. The first argument must be
        a border edge. The new face will be automatically closed. Only works with one
        object selected.
        
        Flags:
        - append : a                     (float, float, float) [create]
            Appends to the given polygon object.  The append flag should be used multiple
            times to specify the edges, points, and holes that make up the new face that is
            being added.  You may specify an edge by passing a single argument which will be
            the edges index.  A point is specified with three arguments which are the
            coordinates of the point in the objects local space.  Pass no arguments
            indicates that the values which follow shall specify a hole.  In Python, pass an
            empty tuple to specify no arguments.
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - edge : ed                      (int)           [create]
            Adds the given edge of the selected object to the new face. This edge must be a
            border, which will be then shared by the new face and the neighboring one. The
            new face is oriented according to the orientation of the given edge(s).  Note
            that this flag should be avoided in Python.  You may use the appendflag instead
            and pass one argument.
        
        - hole : hl                      (bool)          [create]
            Add a hole. The following points and edges will define a hole.  Note that this
            flag should be avoided in Python.  You may use the appendflag instead and pass
            an empty tuple ().
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - point : p                      (float, float, float) [create]
            Adds a new point to the new face. Coordinates of free points are given in the
            local object reference.  Note that this flag should be avoided in Python.  You
            may use the appendflag instead and pass three arguments.
        
        - subdivision : s                (int)           [create,query,edit]
            This flag specifies the level of subdivisions. Automatically subdivides new
            edges into the given number of edges. Existing edges cannot be subdivided. C :
            Default is 1 (no subdivision). Q: When queried, this flag returns an int.
        
        - texture : tx                   (int)           [create,query,edit]
            Specifies how new faces are mapped. 0 - None; 1 - Normalize; 2 - Unitize C:
            Default is 0 (no mapping). Q: When queried, this flag returns an intFlag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyAppend`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TadskAssetInstanceNode_TdnTx2D(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyNormal(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def getNormalMode(self, **kwargs):
        """
        Normal mode     : 0=reverse, 1=propagate, 2=conform, 3=reverseAndCut, 4=reverseAndPropagate Default:0                  
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def getUserNormalMode(self, **kwargs):
        """
        Determines if user normals needs to be reversed as well. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def setNormalMode(self, val='True', **kwargs):
        """
        Normal mode     : 0=reverse, 1=propagate, 2=conform, 3=reverseAndCut, 4=reverseAndPropagate Default:0                  
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    def setUserNormalMode(self, val='True', **kwargs):
        """
        Determines if user normals needs to be reversed as well. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Control the normals of an object. This command works on faces or polygonal
        objects.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - normalMode : nm                (int)           [create,query,edit]
            Normal mode     : 0=reverse, 1=propagate, 2=conform, 3=reverseAndCut,
            4=reverseAndPropagate Default:0
        
        - userNormalMode : unm           (bool)          [create,query,edit]
            Determines if user normals needs to be reversed as well. Default:true
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyNormal`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierCollision(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCollapseEdge(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCollapseEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCollapseEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCollapseEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCollapseEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCollapseEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Turns each selected edge into a point.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCollapseEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Checker(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyReduce(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getCachingReduce(self, **kwargs):
        """
        Cache intermediate reductions for speed at the expense of memory. It is recommended that caching be enabled when using the new algorithm. (-version 1)  However, caching is not recommended when using then old algorithm because it can cause stability issues. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getColorWeights(self, **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. How much consideration vertex color is given in the reduction algorithm. A higher weight means the reduction will try harder to preserve vertex coloring. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getCompactness(self, **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. Tolerance for compactness for the generated triangles A value of 0 will accept all triangles during decimation A value close to 0 will attempt to eliminate triangles that have collinear edges (zero area triangles) A value closer to 1 will attempt to eliminate triangles that are not strictly equilateral (of equal lengths) The closer to 1.0, the more expensive the computation Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getGeomWeights(self, **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. How much consideration vertex positions are given in the reduction algorithm.  A higher weight means the reduction will try harder to preserve geometry. C: Default is 1. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getInvertVertexWeights(self, **kwargs):
        """
        This flag controls how weight map values are interpreted. If true, a vertex weight of 1.0 means a vertex is unlikely to be reduced. If false, a vertex weight of 0.0 means a vertex is unlikely to be reduced. This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepBorder(self, **kwargs):
        """
        If true, reduction will try to retain geometric borders and the border of the selection. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepBorderWeight(self, **kwargs):
        """
        If keepBorder is on, this flag specifies the weight to assign to borders.  Setting this value to 0 will disable border preservation and a value of 1 will exactly preserve all border vertices which is useful for matching adjacent meshes.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepColorBorder(self, **kwargs):
        """
        If true, reduction will try to retain color borders.  These are determined according to color Ids.  This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepColorBorderWeight(self, **kwargs):
        """
        If keepColorBorder is on, this flag specifies the weight to assign to color borders.  Setting this value to 0 will disable color border preservation and a value of 1 will exactly preserve all color borders.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepCreaseEdge(self, **kwargs):
        """
        If true, reduction will try to retain crease edges. C: Default is true.  This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepCreaseEdgeWeight(self, **kwargs):
        """
        If keepCreaseEdge is on, this flag specifies the weight to assign to crease edges.  Setting this value to 0 will disable crease edge preservation and a value of 1 will exactly preserve all crease edges. This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepFaceGroupBorder(self, **kwargs):
        """
        If true, reduction will try to retain borders of face groups, which are mostly used to define material assignments.  This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepFaceGroupBorderWeight(self, **kwargs):
        """
        If keepFaceGroupBorder is on, this flag specifies the weight to assign to material borders.  Setting this value to 0 will disable group border preservation and a value of 1 will exactly preserve all group borders.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepHardEdge(self, **kwargs):
        """
        If true, reduction will try to retain hard edges. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepHardEdgeWeight(self, **kwargs):
        """
        If keepHardEdge is on, this flag specifies the weight to assign to hard edges.  Setting this value to 0 will disable hard edge preservation and a value of 1 will exactly preserve all hard edges. This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepMapBorder(self, **kwargs):
        """
        If true, reduction will try to retain UV borders.  A UV border is present if the faces on either side of the edge do not share UV Ids. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepMapBorderWeight(self, **kwargs):
        """
        If keepMapBorder is on, this flag specifies the weight to assign to UV map borders.  Setting this value to 0 will disable UV map border preservation and a value of 1 will exactly preserve all UV borders. This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepOriginalVertices(self, **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. If true, vertices will try to retain their original positions and will not be repositioned for optimal shape. NOTE: In the newer algorithm vertices always retain their exact original positions. (though the Ids will change) C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getKeepQuadsWeight(self, **kwargs):
        """
        This flag controls how much consideration is given to oreserving quad faces during reduction.  A higher weight means the reduction will try harder to keep quad faces and avoid creation of triangles. If the version flag is set to 1 (-version 1) and the keepQuadsWeight flag is set to 1.0 then a special quad reduction algorithm is used that does a better job of preserving quads. Howver, this special quad reduction algorithm does not support symmetry so those flags will be ignored when the keepQuadsWeight flag is set to 1.0. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getPercentage(self, **kwargs):
        """
        This flag specifies how many vertices to remove during reduction as a percentage of the original mesh.  This flag only applies if the termination flag is set to 0 or when using the old algorithm. C: Default is 0. 100 will remove every possible vertex, 0 will remove none. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getPreserveTopology(self, **kwargs):
        """
        this flag guarantees that the topological type will be preserved during reduction.  In particular, if the input is manifold then the output will be manifold.  This option also prevents holes in the mesh from being closed off. This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getSharpness(self, **kwargs):
        """
        Sharpness controls the balance between preserving small, sharp details versus larger shapes.  At low values, details that are small relative to the general shape of the object are more likely to be collapsed.  At high values, they are more likely to be kept.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getSymmetryPlaneW(self, **kwargs):
        """
        W value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getSymmetryPlaneX(self, **kwargs):
        """
        X value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getSymmetryPlaneY(self, **kwargs):
        """
        Y value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getSymmetryPlaneZ(self, **kwargs):
        """
        Z value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getSymmetryTolerance(self, **kwargs):
        """
        Tolerance to use when applying symmetry. For each vertex of the mesh, we find its exact symmetric point, then we look for the closest vertex to the exact symmetry up to the tolerance distance.  Higher values risk finding more spurious symmetries, lower values might miss symmetries. The value is distance in object space.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is not set to 0. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getTermination(self, **kwargs):
        """
        This flag specifies the termination condition to use when reducing the mesh.  This flag only applies to the new algorithm. (-version 1) 0 Percentage 1 Vertex count 2 Triangle count C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getTriangleCount(self, **kwargs):
        """
        This flag specifies a target number of triangles to retain after reduction. Note that other factors such as quad and feature preservation may take precendence and cause the actual number of triangles to be different. This flag only applies when using the new algorithm (-version 1) and the termination flag is set to 2. C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getTriangulate(self, **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. This attribute specifies if the geometry or the selected faces has to be triangulated, before performing reduction. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getUseVirtualSymmetry(self, **kwargs):
        """
        This flag controls whether symmetry is preserved during the reduction. This flag only applies when using the new algorithm (-version 1) and the keepQuadsWeight flag is less than 1.0. 0 No symmetry preservation 1 Automatic. Try to find suitable symmetry during reduction. 2 Plane.  Specify a symmetry plane to use during reduction. C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getUvWeights(self, **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. How much consideration uv positions are given in the reduction algorithm. A higher weight means the reduction will try harder to preserve uv positions. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Version of the poly reduce algorithm to use. 0 Old algorithm used in Maya 2013 and prior for backwards compatibility 1 New algorithm derived from Softimage and used in Maya 2014 and later The default is 0 for backwards compatibility but for best results it is recommended that the new algorithm is used as it is better at preserving mesh details. Some flags only apply to a specific algorithm and this is documented for each flag. C: Default is 0 for backwards compatibility. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getVertexCount(self, **kwargs):
        """
        This flag specifies a target number of vertices to retain after reduction. Note that other factors such as quad and feature preservation may take precendence and cause the actual number of vertices to be different. This flag only applies when using the new algorithm (-version 1) and the termination flag is set to 1. C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getVertexMapName(self, **kwargs):
        """
        Name of a color set to be added to the output mesh that stores a mapping from vertices in the output mesh to vertices in the input mesh.  The color set is RGB.  The original vertex Id that maps to an output vertex is of a vertex is 65536\*r + g where r and g are the red and green channel at a vertex. The blue channel is always zero.  Each vertex in the output mesh has a shared color. This flag only applies when using the new algorithm. (-version 1) Q: When queried, this flag returns a string.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getVertexWeightCoefficient(self, **kwargs):
        """
        This flag specifies a constant value to multiply to each weight map value. A value of zero turns off the weight map.  This flag only applies when using the new algorithm. (-version 1) C: Default is 1. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def getWeightCoefficient(self, **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. The weight of each vertex is multiplied with this coefficient when the reduction is performed.  This value does not have to be edited, normally.  It gives finer control over the weighted reduction. This attribute is replaced by vertexWeightCoefficient in the new algorithm when the version flag is set to 1. C: Default is 10000. Q: When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setCachingReduce(self, val='True', **kwargs):
        """
        Cache intermediate reductions for speed at the expense of memory. It is recommended that caching be enabled when using the new algorithm. (-version 1)  However, caching is not recommended when using then old algorithm because it can cause stability issues. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setColorWeights(self, val='True', **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. How much consideration vertex color is given in the reduction algorithm. A higher weight means the reduction will try harder to preserve vertex coloring. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setCompactness(self, val='True', **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. Tolerance for compactness for the generated triangles A value of 0 will accept all triangles during decimation A value close to 0 will attempt to eliminate triangles that have collinear edges (zero area triangles) A value closer to 1 will attempt to eliminate triangles that are not strictly equilateral (of equal lengths) The closer to 1.0, the more expensive the computation Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setGeomWeights(self, val='True', **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. How much consideration vertex positions are given in the reduction algorithm.  A higher weight means the reduction will try harder to preserve geometry. C: Default is 1. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setInvertVertexWeights(self, val='True', **kwargs):
        """
        This flag controls how weight map values are interpreted. If true, a vertex weight of 1.0 means a vertex is unlikely to be reduced. If false, a vertex weight of 0.0 means a vertex is unlikely to be reduced. This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepBorder(self, val='True', **kwargs):
        """
        If true, reduction will try to retain geometric borders and the border of the selection. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepBorderWeight(self, val='True', **kwargs):
        """
        If keepBorder is on, this flag specifies the weight to assign to borders.  Setting this value to 0 will disable border preservation and a value of 1 will exactly preserve all border vertices which is useful for matching adjacent meshes.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepColorBorder(self, val='True', **kwargs):
        """
        If true, reduction will try to retain color borders.  These are determined according to color Ids.  This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepColorBorderWeight(self, val='True', **kwargs):
        """
        If keepColorBorder is on, this flag specifies the weight to assign to color borders.  Setting this value to 0 will disable color border preservation and a value of 1 will exactly preserve all color borders.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepCreaseEdge(self, val='True', **kwargs):
        """
        If true, reduction will try to retain crease edges. C: Default is true.  This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepCreaseEdgeWeight(self, val='True', **kwargs):
        """
        If keepCreaseEdge is on, this flag specifies the weight to assign to crease edges.  Setting this value to 0 will disable crease edge preservation and a value of 1 will exactly preserve all crease edges. This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepFaceGroupBorder(self, val='True', **kwargs):
        """
        If true, reduction will try to retain borders of face groups, which are mostly used to define material assignments.  This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepFaceGroupBorderWeight(self, val='True', **kwargs):
        """
        If keepFaceGroupBorder is on, this flag specifies the weight to assign to material borders.  Setting this value to 0 will disable group border preservation and a value of 1 will exactly preserve all group borders.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepHardEdge(self, val='True', **kwargs):
        """
        If true, reduction will try to retain hard edges. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepHardEdgeWeight(self, val='True', **kwargs):
        """
        If keepHardEdge is on, this flag specifies the weight to assign to hard edges.  Setting this value to 0 will disable hard edge preservation and a value of 1 will exactly preserve all hard edges. This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepMapBorder(self, val='True', **kwargs):
        """
        If true, reduction will try to retain UV borders.  A UV border is present if the faces on either side of the edge do not share UV Ids. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepMapBorderWeight(self, val='True', **kwargs):
        """
        If keepMapBorder is on, this flag specifies the weight to assign to UV map borders.  Setting this value to 0 will disable UV map border preservation and a value of 1 will exactly preserve all UV borders. This flag only applies when using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepOriginalVertices(self, val='True', **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. If true, vertices will try to retain their original positions and will not be repositioned for optimal shape. NOTE: In the newer algorithm vertices always retain their exact original positions. (though the Ids will change) C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setKeepQuadsWeight(self, val='True', **kwargs):
        """
        This flag controls how much consideration is given to oreserving quad faces during reduction.  A higher weight means the reduction will try harder to keep quad faces and avoid creation of triangles. If the version flag is set to 1 (-version 1) and the keepQuadsWeight flag is set to 1.0 then a special quad reduction algorithm is used that does a better job of preserving quads. Howver, this special quad reduction algorithm does not support symmetry so those flags will be ignored when the keepQuadsWeight flag is set to 1.0. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setPercentage(self, val='True', **kwargs):
        """
        This flag specifies how many vertices to remove during reduction as a percentage of the original mesh.  This flag only applies if the termination flag is set to 0 or when using the old algorithm. C: Default is 0. 100 will remove every possible vertex, 0 will remove none. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setPreserveTopology(self, val='True', **kwargs):
        """
        this flag guarantees that the topological type will be preserved during reduction.  In particular, if the input is manifold then the output will be manifold.  This option also prevents holes in the mesh from being closed off. This flag only applies when using the new algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setSharpness(self, val='True', **kwargs):
        """
        Sharpness controls the balance between preserving small, sharp details versus larger shapes.  At low values, details that are small relative to the general shape of the object are more likely to be collapsed.  At high values, they are more likely to be kept.  This flag only applies when using the new algorithm. (-version 1) C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setSymmetryPlaneW(self, val='True', **kwargs):
        """
        W value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setSymmetryPlaneX(self, val='True', **kwargs):
        """
        X value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setSymmetryPlaneY(self, val='True', **kwargs):
        """
        Y value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setSymmetryPlaneZ(self, val='True', **kwargs):
        """
        Z value of the symmetry plane.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setSymmetryTolerance(self, val='True', **kwargs):
        """
        Tolerance to use when applying symmetry. For each vertex of the mesh, we find its exact symmetric point, then we look for the closest vertex to the exact symmetry up to the tolerance distance.  Higher values risk finding more spurious symmetries, lower values might miss symmetries. The value is distance in object space.  This flag only applies when using the new algorithm (-version 1) and the useVirtualSymmetry flag is not set to 0. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setTermination(self, val='True', **kwargs):
        """
        This flag specifies the termination condition to use when reducing the mesh.  This flag only applies to the new algorithm. (-version 1) 0 Percentage 1 Vertex count 2 Triangle count C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setTriangleCount(self, val='True', **kwargs):
        """
        This flag specifies a target number of triangles to retain after reduction. Note that other factors such as quad and feature preservation may take precendence and cause the actual number of triangles to be different. This flag only applies when using the new algorithm (-version 1) and the termination flag is set to 2. C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setTriangulate(self, val='True', **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. This attribute specifies if the geometry or the selected faces has to be triangulated, before performing reduction. C: Default is true. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setUseVirtualSymmetry(self, val='True', **kwargs):
        """
        This flag controls whether symmetry is preserved during the reduction. This flag only applies when using the new algorithm (-version 1) and the keepQuadsWeight flag is less than 1.0. 0 No symmetry preservation 1 Automatic. Try to find suitable symmetry during reduction. 2 Plane.  Specify a symmetry plane to use during reduction. C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setUvWeights(self, val='True', **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. How much consideration uv positions are given in the reduction algorithm. A higher weight means the reduction will try harder to preserve uv positions. C: Default is 0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Version of the poly reduce algorithm to use. 0 Old algorithm used in Maya 2013 and prior for backwards compatibility 1 New algorithm derived from Softimage and used in Maya 2014 and later The default is 0 for backwards compatibility but for best results it is recommended that the new algorithm is used as it is better at preserving mesh details. Some flags only apply to a specific algorithm and this is documented for each flag. C: Default is 0 for backwards compatibility. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setVertexCount(self, val='True', **kwargs):
        """
        This flag specifies a target number of vertices to retain after reduction. Note that other factors such as quad and feature preservation may take precendence and cause the actual number of vertices to be different. This flag only applies when using the new algorithm (-version 1) and the termination flag is set to 1. C: Default is 0. Q: When queried, this flag returns an integer.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setVertexWeightCoefficient(self, val='True', **kwargs):
        """
        This flag specifies a constant value to multiply to each weight map value. A value of zero turns off the weight map.  This flag only applies when using the new algorithm. (-version 1) C: Default is 1. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    def setWeightCoefficient(self, val='True', **kwargs):
        """
        This flag only applies when using the old algorithm and is provided for backwards compatibility. The weight of each vertex is multiplied with this coefficient when the reduction is performed.  This value does not have to be edited, normally.  It gives finer control over the weighted reduction. This attribute is replaced by vertexWeightCoefficient in the new algorithm when the version flag is set to 1. C: Default is 10000. Q: When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Simplify a polygonal object by reducing geometry while preserving the overall
        shape of the mesh. The algorithm for polyReduce was changed in 2014 to use a new
        algorithm derived from Softimage. However, the command still defaults to using
        the old algorithm for backwards compatibility.  Therefore, we recommend setting
        the version flag to 1 for best results as the new algorithm is better at
        preserving geometry features.  Additionally, some flags only apply to a specific
        algorithm and this is documented for each flag.
        
        Flags:
        - border : b                     (float)         []
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - cachingReduce : cr             (bool)          [create,query,edit]
            Cache intermediate reductions for speed at the expense of memory. It is
            recommended that caching be enabled when using the new algorithm. (-version 1)
            However, caching is not recommended when using then old algorithm because it can
            cause stability issues. C: Default is false. Q: When queried, this flag returns
            a boolean.
        
        - colorWeights : cwt             (float)         [create,query,edit]
            This flag only applies when using the old algorithm and is provided for
            backwards compatibility. How much consideration vertex color is given in the
            reduction algorithm. A higher weight means the reduction will try harder to
            preserve vertex coloring. C: Default is 0. Q: When queried, this flag returns a
            float.
        
        - compactness : com              (float)         [create,query,edit]
            This flag only applies when using the old algorithm and is provided for
            backwards compatibility. Tolerance for compactness for the generated triangles A
            value of 0 will accept all triangles during decimation A value close to 0 will
            attempt to eliminate triangles that have collinear edges (zero area triangles) A
            value closer to 1 will attempt to eliminate triangles that are not strictly
            equilateral (of equal lengths) The closer to 1.0, the more expensive the
            computation Q: When queried, this flag returns a float.
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - detail : d                     (float)         []
        
        - frozen : fzn                   (bool)          []
        
        - geomWeights : gwt              (float)         [create,query,edit]
            This flag only applies when using the old algorithm and is provided for
            backwards compatibility. How much consideration vertex positions are given in
            the reduction algorithm.  A higher weight means the reduction will try harder to
            preserve geometry. C: Default is 1. Q: When queried, this flag returns a float.
        
        - invertVertexWeights : iwt      (bool)          [create,query,edit]
            This flag controls how weight map values are interpreted. If true, a vertex
            weight of 1.0 means a vertex is unlikely to be reduced. If false, a vertex
            weight of 0.0 means a vertex is unlikely to be reduced. This flag only applies
            when using the new algorithm. (-version 1) C: Default is true. Q: When queried,
            this flag returns a boolean.
        
        - keepBorder : kb                (bool)          [create,query,edit]
            If true, reduction will try to retain geometric borders and the border of the
            selection. C: Default is true. Q: When queried, this flag returns a boolean.
        
        - keepBorderWeight : kbw         (float)         [create,query,edit]
            If keepBorder is on, this flag specifies the weight to assign to borders.
            Setting this value to 0 will disable border preservation and a value of 1 will
            exactly preserve all border vertices which is useful for matching adjacent
            meshes.  This flag only applies when using the new algorithm. (-version 1) C:
            Default is 0.5. Q: When queried, this flag returns a float.
        
        - keepColorBorder : kcb          (bool)          [create,query,edit]
            If true, reduction will try to retain color borders.  These are determined
            according to color Ids.  This flag only applies when using the new algorithm.
            (-version 1) C: Default is true. Q: When queried, this flag returns a boolean.
        
        - keepColorBorderWeight : kcw    (float)         [create,query,edit]
            If keepColorBorder is on, this flag specifies the weight to assign to color
            borders.  Setting this value to 0 will disable color border preservation and a
            value of 1 will exactly preserve all color borders.  This flag only applies when
            using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this
            flag returns a float.
        
        - keepCreaseEdge : kce           (bool)          [create,query,edit]
            If true, reduction will try to retain crease edges. C: Default is true.  This
            flag only applies when using the new algorithm. (-version 1) C: Default is true.
            Q: When queried, this flag returns a boolean.
        
        - keepCreaseEdgeWeight : cew     (float)         [create,query,edit]
            If keepCreaseEdge is on, this flag specifies the weight to assign to crease
            edges.  Setting this value to 0 will disable crease edge preservation and a
            value of 1 will exactly preserve all crease edges. This flag only applies when
            using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this
            flag returns a float.
        
        - keepFaceGroupBorder : kfb      (bool)          [create,query,edit]
            If true, reduction will try to retain borders of face groups, which are mostly
            used to define material assignments.  This flag only applies when using the new
            algorithm. (-version 1) C: Default is true. Q: When queried, this flag returns a
            boolean.
        
        - keepFaceGroupBorderWeight : kfw (float)         [create,query,edit]
            If keepFaceGroupBorder is on, this flag specifies the weight to assign to
            material borders.  Setting this value to 0 will disable group border
            preservation and a value of 1 will exactly preserve all group borders.  This
            flag only applies when using the new algorithm. (-version 1) C: Default is 0.5.
            Q: When queried, this flag returns a float.
        
        - keepHardEdge : khe             (bool)          [create,query,edit]
            If true, reduction will try to retain hard edges. C: Default is true. Q: When
            queried, this flag returns a boolean.
        
        - keepHardEdgeWeight : khw       (float)         [create,query,edit]
            If keepHardEdge is on, this flag specifies the weight to assign to hard edges.
            Setting this value to 0 will disable hard edge preservation and a value of 1
            will exactly preserve all hard edges. This flag only applies when using the new
            algorithm. (-version 1) C: Default is 0.5. Q: When queried, this flag returns a
            float.
        
        - keepMapBorder : kmb            (bool)          [create,query,edit]
            If true, reduction will try to retain UV borders.  A UV border is present if the
            faces on either side of the edge do not share UV Ids. C: Default is true. Q:
            When queried, this flag returns a boolean.
        
        - keepMapBorderWeight : kmw      (float)         [create,query,edit]
            If keepMapBorder is on, this flag specifies the weight to assign to UV map
            borders.  Setting this value to 0 will disable UV map border preservation and a
            value of 1 will exactly preserve all UV borders. This flag only applies when
            using the new algorithm. (-version 1) C: Default is 0.5. Q: When queried, this
            flag returns a float.
        
        - keepOriginalVertices : kev     (bool)          [create,query,edit]
            This flag only applies when using the old algorithm and is provided for
            backwards compatibility. If true, vertices will try to retain their original
            positions and will not be repositioned for optimal shape. NOTE: In the newer
            algorithm vertices always retain their exact original positions. (though the Ids
            will change) C: Default is false. Q: When queried, this flag returns a boolean.
        
        - keepQuadsWeight : kqw          (float)         [create,query,edit]
            This flag controls how much consideration is given to oreserving quad faces
            during reduction.  A higher weight means the reduction will try harder to keep
            quad faces and avoid creation of triangles. If the version flag is set to 1
            (-version 1) and the keepQuadsWeight flag is set to 1.0 then a special quad
            reduction algorithm is used that does a better job of preserving quads. Howver,
            this special quad reduction algorithm does not support symmetry so those flags
            will be ignored when the keepQuadsWeight flag is set to 1.0. C: Default is 0. Q:
            When queried, this flag returns a float.
        
        - line : l                       (float)         []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - percentage : p                 (float)         [create,query,edit]
            This flag specifies how many vertices to remove during reduction as a percentage
            of the original mesh.  This flag only applies if the termination flag is set to
            0 or when using the old algorithm. C: Default is 0. 100 will remove every
            possible vertex, 0 will remove none. Q: When queried, this flag returns a float.
        
        - preserveLocation : pl          (bool)          [create]
            This flag guarantees that if the original geometry is preserved, the new
            geometry will have the same location. C: Default is false.
        
        - preserveTopology : top         (bool)          [create,query,edit]
            this flag guarantees that the topological type will be preserved during
            reduction.  In particular, if the input is manifold then the output will be
            manifold.  This option also prevents holes in the mesh from being closed off.
            This flag only applies when using the new algorithm. (-version 1) C: Default is
            true. Q: When queried, this flag returns a boolean.
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace) (not available in all commands). NOTE: This flag
            is intended for use by the Reducemenu item. If 'polyReduce -rpo 0' is executed
            from the command line, Shader information will not be copied from the original
            mesh to the result.
        
        - sharpness : shp                (float)         [create,query,edit]
            Sharpness controls the balance between preserving small, sharp details versus
            larger shapes.  At low values, details that are small relative to the general
            shape of the object are more likely to be collapsed.  At high values, they are
            more likely to be kept.  This flag only applies when using the new algorithm.
            (-version 1) C: Default is 0. Q: When queried, this flag returns a float.
        
        - symmetryPlane : sym            (float, float, float, float) []
        
        - symmetryPlaneW : sw            (float)         [create,query,edit]
            W value of the symmetry plane.  This flag only applies when using the new
            algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default
            is 0. Q: When queried, this flag returns a float.
        
        - symmetryPlaneX : sx            (float)         [create,query,edit]
            X value of the symmetry plane.  This flag only applies when using the new
            algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default
            is 0. Q: When queried, this flag returns a float.
        
        - symmetryPlaneY : sy            (float)         [create,query,edit]
            Y value of the symmetry plane.  This flag only applies when using the new
            algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default
            is 0. Q: When queried, this flag returns a float.
        
        - symmetryPlaneZ : sz            (float)         [create,query,edit]
            Z value of the symmetry plane.  This flag only applies when using the new
            algorithm (-version 1) and the useVirtualSymmetry flag is set to 2. C: Default
            is 0. Q: When queried, this flag returns a float.
        
        - symmetryTolerance : stl        (float)         [create,query,edit]
            Tolerance to use when applying symmetry. For each vertex of the mesh, we find
            its exact symmetric point, then we look for the closest vertex to the exact
            symmetry up to the tolerance distance.  Higher values risk finding more spurious
            symmetries, lower values might miss symmetries. The value is distance in object
            space.  This flag only applies when using the new algorithm (-version 1) and the
            useVirtualSymmetry flag is not set to 0. C: Default is 0. Q: When queried, this
            flag returns a float.
        
        - termination : trm              (int)           [create,query,edit]
            This flag specifies the termination condition to use when reducing the mesh.
            This flag only applies to the new algorithm. (-version 1) 0 Percentage 1 Vertex
            count 2 Triangle count C: Default is 0. Q: When queried, this flag returns an
            integer.
        
        - triangleCount : tct            (int)           [create,query,edit]
            This flag specifies a target number of triangles to retain after reduction. Note
            that other factors such as quad and feature preservation may take precendence
            and cause the actual number of triangles to be different. This flag only applies
            when using the new algorithm (-version 1) and the termination flag is set to 2.
            C: Default is 0. Q: When queried, this flag returns an integer.
        
        - triangulate : t                (bool)          [create,query,edit]
            This flag only applies when using the old algorithm and is provided for
            backwards compatibility. This attribute specifies if the geometry or the
            selected faces has to be triangulated, before performing reduction. C: Default
            is true. Q: When queried, this flag returns a boolean.
        
        - useVirtualSymmetry : uvs       (int)           [create,query,edit]
            This flag controls whether symmetry is preserved during the reduction. This flag
            only applies when using the new algorithm (-version 1) and the keepQuadsWeight
            flag is less than 1.0. 0 No symmetry preservation 1 Automatic. Try to find
            suitable symmetry during reduction. 2 Plane.  Specify a symmetry plane to use
            during reduction. C: Default is 0. Q: When queried, this flag returns an
            integer.
        
        - uvWeights : uwt                (float)         [create,query,edit]
            This flag only applies when using the old algorithm and is provided for
            backwards compatibility. How much consideration uv positions are given in the
            reduction algorithm. A higher weight means the reduction will try harder to
            preserve uv positions. C: Default is 0. Q: When queried, this flag returns a
            float.
        
        - version : ver                  (int)           [create,query,edit]
            Version of the poly reduce algorithm to use. 0 Old algorithm used in Maya 2013
            and prior for backwards compatibility 1 New algorithm derived from Softimage and
            used in Maya 2014 and later The default is 0 for backwards compatibility but for
            best results it is recommended that the new algorithm is used as it is better at
            preserving mesh details. Some flags only apply to a specific algorithm and this
            is documented for each flag. C: Default is 0 for backwards compatibility. Q:
            When queried, this flag returns an integer.
        
        - vertexCount : vct              (int)           [create,query,edit]
            This flag specifies a target number of vertices to retain after reduction. Note
            that other factors such as quad and feature preservation may take precendence
            and cause the actual number of vertices to be different. This flag only applies
            when using the new algorithm (-version 1) and the termination flag is set to 1.
            C: Default is 0. Q: When queried, this flag returns an integer.
        
        - vertexMapName : vmp            (unicode)       [create,query]
            Name of a color set to be added to the output mesh that stores a mapping from
            vertices in the output mesh to vertices in the input mesh.  The color set is
            RGB.  The original vertex Id that maps to an output vertex is of a vertex is
            65536\*r + g where r and g are the red and green channel at a vertex. The blue
            channel is always zero.  Each vertex in the output mesh has a shared color. This
            flag only applies when using the new algorithm. (-version 1) Q: When queried,
            this flag returns a string.
        
        - vertexWeightCoefficient : vwc  (float)         [create,query,edit]
            This flag specifies a constant value to multiply to each weight map value. A
            value of zero turns off the weight map.  This flag only applies when using the
            new algorithm. (-version 1) C: Default is 1. Q: When queried, this flag returns
            a float.
        
        - weightCoefficient : wc         (float)         [create,query,edit]
            This flag only applies when using the old algorithm and is provided for
            backwards compatibility. The weight of each vertex is multiplied with this
            coefficient when the reduction is performed.  This value does not have to be
            edited, normally.  It gives finer control over the weighted reduction. This
            attribute is replaced by vertexWeightCoefficient in the new algorithm when the
            version flag is set to 1. C: Default is 10000. Q: When queried, this flag
            returns a float.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyReduce`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCollapseF(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class SpBirailSrf(BirailSrf):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySplitEdge(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    def getOperation(self, **kwargs):
        """
        0 means use a Non-Manifold method, 1 means use a Manifold method                  Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    def setOperation(self, val='True', **kwargs):
        """
        0 means use a Non-Manifold method, 1 means use a Manifold method                  Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Split Edges.There are two operations for this command depending on the value of
        the -operation flag. If -operation is set to 1 then this command will split
        apart faces along all selected manifold edges. If -operation is set to 0 then
        this command will split non-manifold edges so as to make them manifold edges. It
        creates the minimum number of edges that can be created to make the edge
        manifold. The default value for -operation is 1, operate on manifold edges.
        Resulting mesh may have extra vertices or edges to ensure geometry is valid.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - operation : op                 (int)           [create,query,edit]
            0 means use a Non-Manifold method, 1 means use a Manifold method
            Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polySplitEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Orient(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyTransfer(PolyModifier):
    def getAlternateObject(self, **kwargs):
        """
        Name of the alternate object.                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def getUvSets(self, **kwargs):
        """
        When true, the UV sets are copied from the alternate object. C: Default is on.                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def getVertexColor(self, **kwargs):
        """
        When true, the colors per vertex are copied from the alternate object. C: Default is off.                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def getVertices(self, **kwargs):
        """
        When true, the vertices positions are copied from the alternate object. C: Default is off.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def setAlternateObject(self, val='True', **kwargs):
        """
        Name of the alternate object.                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def setUvSets(self, val='True', **kwargs):
        """
        When true, the UV sets are copied from the alternate object. C: Default is on.                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def setVertexColor(self, val='True', **kwargs):
        """
        When true, the colors per vertex are copied from the alternate object. C: Default is off.                  
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    def setVertices(self, val='True', **kwargs):
        """
        When true, the vertices positions are copied from the alternate object. C: Default is off.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Transfer information from one polygonal object to another one. Both objects must
        have identical topology, that is same vertex, edge, and face numbering. The
        flags specify which of the vertices, UV sets or vertex colors will be copied.
        
        Flags:
        - alternateObject : ao           (unicode)       [create,query,edit]
            Name of the alternate object.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - uvSets : uv                    (bool)          [create,query,edit]
            When true, the UV sets are copied from the alternate object. C: Default is on.
        
        - vertexColor : vc               (bool)          [create,query,edit]
            When true, the colors per vertex are copied from the alternate object. C:
            Default is off.
        
        - vertices : v                   (bool)          [create,query,edit]
            When true, the vertices positions are copied from the alternate object. C:
            Default is off.                  Flag can have multiple arguments, passed either
            as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyTransfer`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbsOverride(ApplyOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyColorDel(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    def getColorSetName(self, **kwargs):
        """
        The name of the color set to work on                  
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    def setColorSetName(self, val='True', **kwargs):
        """
        The name of the color set to work on                  
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Deletes color from selected components.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - colorSetName : cls             (unicode)       [create,query,edit]
            The name of the color set to work on
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyColorDel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Mandelbrot(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySmooth(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getContinuity(self, **kwargs):
        """
        This flag specifies the smoothness parameter. The minimum value of 0.0 specifies that the faces should only be subdivided. Maximum value of 1.0 smooths the faces as much as possible. C: Default is 1.0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getDivisions(self, **kwargs):
        """
        This flag specifies the number of recursive smoothing steps. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getKeepBorder(self, **kwargs):
        """
        If on, the border of the object will not move during smoothing operation. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getKeepHardEdge(self, **kwargs):
        """
        If true, vertices on hard edges will not be modified. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getKeepSelectionBorder(self, **kwargs):
        """
        If true, vertices on border of the selection will not be modified. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flags From The polySmoothFacet Node
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getOsdCreaseMethod(self, **kwargs):
        """
        Controls how boundary edges and vertices are interpolated.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getOsdFvarBoundary(self, **kwargs):
        """
        Controls how boundaries are treated for face-varying data (UVs and Vertex Colors).                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getOsdFvarPropagateCorners(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getOsdSmoothTriangles(self, **kwargs):
        """
        Apply a special subdivision rule be applied to all triangular faces that was empirically determined to make triangles subdivide more smoothly.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getOsdVertBoundary(self, **kwargs):
        """
        Controls how boundary edges and vertices are interpolated.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getPropagateEdgeHardness(self, **kwargs):
        """
        If true, edges which are a result of smoothed edges will be given the same value for their edge hardness.  New subdivided edges will always be smooth. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def getSubdivisionType(self, **kwargs):
        """
        The subdivision method used for smoothing. C: Default is 0. 0: Maya Catmull-Clark 1: OpenSubdiv Catmull-Clark                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setContinuity(self, val='True', **kwargs):
        """
        This flag specifies the smoothness parameter. The minimum value of 0.0 specifies that the faces should only be subdivided. Maximum value of 1.0 smooths the faces as much as possible. C: Default is 1.0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setDivisions(self, val='True', **kwargs):
        """
        This flag specifies the number of recursive smoothing steps. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setKeepBorder(self, val='True', **kwargs):
        """
        If on, the border of the object will not move during smoothing operation. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setKeepHardEdge(self, val='True', **kwargs):
        """
        If true, vertices on hard edges will not be modified. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setKeepSelectionBorder(self, val='True', **kwargs):
        """
        If true, vertices on border of the selection will not be modified. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flags From The polySmoothFacet Node
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setOsdCreaseMethod(self, val='True', **kwargs):
        """
        Controls how boundary edges and vertices are interpolated.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setOsdFvarBoundary(self, val='True', **kwargs):
        """
        Controls how boundaries are treated for face-varying data (UVs and Vertex Colors).                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setOsdFvarPropagateCorners(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setOsdSmoothTriangles(self, val='True', **kwargs):
        """
        Apply a special subdivision rule be applied to all triangular faces that was empirically determined to make triangles subdivide more smoothly.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setOsdVertBoundary(self, val='True', **kwargs):
        """
        Controls how boundary edges and vertices are interpolated.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setPropagateEdgeHardness(self, val='True', **kwargs):
        """
        If true, edges which are a result of smoothed edges will be given the same value for their edge hardness.  New subdivided edges will always be smooth. C: Default is false. Q: When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    def setSubdivisionType(self, val='True', **kwargs):
        """
        The subdivision method used for smoothing. C: Default is 0. 0: Maya Catmull-Clark 1: OpenSubdiv Catmull-Clark                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Smooth a polygonal object. This command works on polygonal objects or faces.
        
        Flags:
        - boundaryRule : bnr             (int)           []
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - continuity : c                 (float)         [create,query,edit]
            This flag specifies the smoothness parameter. The minimum value of 0.0 specifies
            that the faces should only be subdivided. Maximum value of 1.0 smooths the faces
            as much as possible. C: Default is 1.0 Q: When queried, this flag returns a
            float.
        
        - degree : deg                   (int)           [create]
            Degree of the resulting limit surface
        
        - divisions : dv                 (int)           [create,query,edit]
            This flag specifies the number of recursive smoothing steps. C: Default is 1. Q:
            When queried, this flag returns an int.
        
        - divisionsPerEdge : dpe         (int)           [create]
            Number of subdivisions along one edge for each step.
        
        - frozen : fzn                   (bool)          []
        
        - keepBorder : kb                (bool)          [create,query,edit]
            If on, the border of the object will not move during smoothing operation. C:
            Default is on. Q: When queried, this flag returns an int.
        
        - keepHardEdge : khe             (bool)          [create,query,edit]
            If true, vertices on hard edges will not be modified. C: Default is false. Q:
            When queried, this flag returns a boolean.
        
        - keepMapBorders : kmb           (int)           [create]
            Treatment of UV map borders 0 - all map border edges will be smoothed 1 - map
            borders that are also geometry borders will be smoothed 2 - no map borders will
            be smoothed
        
        - keepSelectionBorder : ksb      (bool)          [create,query,edit]
            If true, vertices on border of the selection will not be modified. C: Default is
            false. Q: When queried, this flag returns a boolean.
        
        - keepTesselation : xkt          (bool)          [create]
            If true: the object will be smoothed consistently from frame to frame. This is
            best when the object is being deformed or animated . If false: non-starlike
            faces will be triangulated before being smoothed.  This avoids self-overlapping
            faces, but could lead to a change in topology (number of vertices/faces) from
            frame to frame, during an animated deformation.
        
        - keepTessellation : kt          (bool)          [create]
            If true: the object will be smoothed consistently from frame to frame. This is
            best when the object is being deformed or animated . If false: non-starlike
            faces will be triangulated before being smoothed.  This avoids self-overlapping
            faces, but could lead to a change in topology (number of vertices/faces) from
            frame to frame, during an animated deformation.
        
        - method : mth                   (int)           [create]
            Type of smoothing algorithm to use 0 - exponential - traditional smoothing 1 -
            linear - number of faces per edge grows linearly
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flags From The
            polySmoothFacet Node
        
        - osdCreaseMethod : ocr          (int)           [create,query,edit]
            Controls how boundary edges and vertices are interpolated.
        
        - osdFvarBoundary : ofb          (int)           [create,query,edit]
            Controls how boundaries are treated for face-varying data (UVs and Vertex
            Colors).
        
        - osdFvarPropagateCorners : ofc  (bool)          [create,query,edit]
        
        - osdSmoothTriangles : ost       (bool)          [create,query,edit]
            Apply a special subdivision rule be applied to all triangular faces that was
            empirically determined to make triangles subdivide more smoothly.
        
        - osdVertBoundary : ovb          (int)           [create,query,edit]
            Controls how boundary edges and vertices are interpolated.
        
        - propagateEdgeHardness : peh    (bool)          [create,query,edit]
            If true, edges which are a result of smoothed edges will be given the same value
            for their edge hardness.  New subdivided edges will always be smooth. C: Default
            is false. Q: When queried, this flag returns a boolean.
        
        - pushStrength : ps              (float)         [create]
            COMMENT 0.0 is approximation, 1.0 is interpolation scheme
        
        - roundness : ro                 (float)         [create]
            When 1.0, push vectors are renormalized to keep length constant
        
        - smoothUVs : suv                (bool)          [create]
            If true: UVs as well as geometry will be smoothed
        
        - subdivisionLevels : sl         (int)           [create]
            Number of times the subdivide and smooth operation is run.
        
        - subdivisionType : sdt          (int)           [create,query,edit]
            The subdivision method used for smoothing. C: Default is 0. 0: Maya Catmull-
            Clark 1: OpenSubdiv Catmull-Clark                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polySmooth`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyColorMod(PolyModifier):
    def getAlphaScale_FloatValue(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getAlphaScale_Interp(self, **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getAlphaScale_Position(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getBlueScale_FloatValue(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getBlueScale_Interp(self, **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getBlueScale_Position(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getGreenScale_FloatValue(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getGreenScale_Interp(self, **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getGreenScale_Position(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getHuev(self, **kwargs):
        """
        Huerotates hue value of the final color. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getIntensityScale_FloatValue(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getIntensityScale_Interp(self, **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getIntensityScale_Position(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getRedScale_FloatValue(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getRedScale_Interp(self, **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getRedScale_Position(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getSatv(self, **kwargs):
        """
        Satscales the staturation of the final color. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def getValue(self, **kwargs):
        """
        Valuescales the final color value. Default:1.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setAlphaScale_FloatValue(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setAlphaScale_Interp(self, val='True', **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setAlphaScale_Position(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setBlueScale_FloatValue(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setBlueScale_Interp(self, val='True', **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setBlueScale_Position(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setGreenScale_FloatValue(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setGreenScale_Interp(self, val='True', **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setGreenScale_Position(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setHuev(self, val='True', **kwargs):
        """
        Huerotates hue value of the final color. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setIntensityScale_FloatValue(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setIntensityScale_Interp(self, val='True', **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setIntensityScale_Position(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setRedScale_FloatValue(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setRedScale_Interp(self, val='True', **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setRedScale_Position(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setSatv(self, val='True', **kwargs):
        """
        Satscales the staturation of the final color. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Valuescales the final color value. Default:1.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Modifies the attributes of a poly color set.
        
        Flags:
        - alphaScale_FloatValue : afv    (float)         [create,query,edit]
            ?????
        
        - alphaScale_Interp : ai         (int)           [create,query,edit]
            ????? Default:0
        
        - alphaScale_Position : ap       (float)         [create,query,edit]
            ?????
        
        - baseColorName : bcn            (unicode)       [create]
            The name of the color set to be modified.
        
        - blueScale_FloatValue : bfv     (float)         [create,query,edit]
            ?????
        
        - blueScale_Interp : bi          (int)           [create,query,edit]
            ????? Default:0
        
        - blueScale_Position : bp        (float)         [create,query,edit]
            ?????
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - greenScale_FloatValue : gfv    (float)         [create,query,edit]
            ?????
        
        - greenScale_Interp : gi         (int)           [create,query,edit]
            ????? Default:0
        
        - greenScale_Position : gp       (float)         [create,query,edit]
            ?????
        
        - huev : h                       (float)         [create,query,edit]
            Huerotates hue value of the final color. Default:0.0
        
        - intensityScale_FloatValue : nfv (float)         [create,query,edit]
            ?????
        
        - intensityScale_Interp : ni     (int)           [create,query,edit]
            ????? Default:0
        
        - intensityScale_Position : np   (float)         [create,query,edit]
            ?????
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - redScale_FloatValue : rfv      (float)         [create,query,edit]
            ?????
        
        - redScale_Interp : ri           (int)           [create,query,edit]
            ????? Default:0
        
        - redScale_Position : rp         (float)         [create,query,edit]
            ?????
        
        - satv : s                       (float)         [create,query,edit]
            Satscales the staturation of the final color. Default:1.0
        
        - value : v                      (float)         [create,query,edit]
            Valuescales the final color value. Default:1.0                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyColorMod`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySplit(PolyModifier):
    def getAdjustEdgeFlow(self, **kwargs):
        """
        The weight value of the edge vertices to be positioned.                  
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    def getInsertWithEdgeFlow(self, **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled.                  
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    def getSubdivision(self, **kwargs):
        """
        Subdivide new edges into the given number of sections. Edges involving free points won't be subdivided. C: Default is 1 (no subdivision). Q: When queried, this flag returns an int.                  Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    def setAdjustEdgeFlow(self, val='True', **kwargs):
        """
        The weight value of the edge vertices to be positioned.                  
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    def setInsertWithEdgeFlow(self, val='True', **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled.                  
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    def setSubdivision(self, val='True', **kwargs):
        """
        Subdivide new edges into the given number of sections. Edges involving free points won't be subdivided. C: Default is 1 (no subdivision). Q: When queried, this flag returns an int.                  Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Split facets/edges of a polygonal object. The first and last arguments must be
        edges. Intermediate points may lie on either a shared face or an edge which
        neighbors the previous point.
        
        Flags:
        - adjustEdgeFlow : aef           (float)         [create,query,edit]
            The weight value of the edge vertices to be positioned.
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - detachEdges : de               (bool)          [create]
            Value of the detachEdges attribute for the resulting poly split node.
        
        - edgepoint : ep                 (int, float)    [create]
            The given edge is split into two new edges by inserting a new vertex located the
            given percentage along the edge. Note:This flag is not recommended for use from
            Python.  See the insertpoint flag instead.
        
        - facepoint : fp                 (int, float, float, float) [create]
            A new vertex is inserted, lying at the given coordinates inside the given face.
            Coordinates are given in the local object space. Note:This flag is not
            recommended for use from Python.  See the insertpoint flag instead.
        
        - insertWithEdgeFlow : ief       (bool)          [create,query,edit]
            True to enable edge flow. Otherwise, the edge flow is disabled.
        
        - insertpoint : ip               (int, float, float, float) [create]
            This flag allows the caller to insert a new vertex into an edge or a face. To
            insert a new vertex in an edge, pass the index of the edge and a percentage
            along the edge at which to insert the new vertex.  When used to insert a vertex
            into an edge, this flag takes two arguments. To insert a new vertex into a face,
            pass the index of the face and three values which define the coordinates for the
            insertion in local object space.  When used to insert a vertex into a face, this
            flag takes four arguments. This flag replaces the edgepoint and facepoint flags.
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        - projectedCurve : pc            (PyNode)        [create]
            Curves to be projected.
        
        - projectedCurveTolerance : pct  (float)         [create]
            Tolerance for curve projection.
        
        - smoothingangle : sma           (float)         [create]
            Subdivide new edges will be soft if less then this angle. C: Default is 0.0
        
        - subdivision : s                (int)           [create,query,edit]
            Subdivide new edges into the given number of sections. Edges involving free
            points won't be subdivided. C: Default is 1 (no subdivision). Q: When queried,
            this flag returns an int.                  Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polySplit`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdModifierWorld(SubdModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class Mountain(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyTweak(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Curve(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyClean(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def getCleanEdges(self, **kwargs):
        """
        If true, the operation will look for and delete edges that are not associated with any face in the mesh.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def getCleanPartialUVMapping(self, **kwargs):
        """
        If true, the operation will look for any faces on the mesh that do not have complete UV mapping.  Maya requires that all vertices that make up a mesh face have valid UV data associated with them, or that none of the vertices withing the face have associated UVs.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def getCleanUVs(self, **kwargs):
        """
        If true, the operation will look for and delete UVs that are not associated with any face in the mesh.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def getCleanVertices(self, **kwargs):
        """
        If true, the operation will look for and delete vertices that are not associated with any face in the mesh.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Toggle frozen state for a particular node to keep current evaluation state and prevent any other indirect changes to it.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def setCleanEdges(self, val='True', **kwargs):
        """
        If true, the operation will look for and delete edges that are not associated with any face in the mesh.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def setCleanPartialUVMapping(self, val='True', **kwargs):
        """
        If true, the operation will look for any faces on the mesh that do not have complete UV mapping.  Maya requires that all vertices that make up a mesh face have valid UV data associated with them, or that none of the vertices withing the face have associated UVs.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def setCleanUVs(self, val='True', **kwargs):
        """
        If true, the operation will look for and delete UVs that are not associated with any face in the mesh.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def setCleanVertices(self, val='True', **kwargs):
        """
        If true, the operation will look for and delete vertices that are not associated with any face in the mesh.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Toggle frozen state for a particular node to keep current evaluation state and prevent any other indirect changes to it.                  
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        polyClean will attempt to remove components that are invalid in the description
        of a poly mesh.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - cleanEdges : ce                (bool)          [create,query,edit]
            If true, the operation will look for and delete edges that are not associated
            with any face in the mesh.
        
        - cleanPartialUVMapping : cpm    (bool)          [create,query,edit]
            If true, the operation will look for any faces on the mesh that do not have
            complete UV mapping.  Maya requires that all vertices that make up a mesh face
            have valid UV data associated with them, or that none of the vertices withing
            the face have associated UVs.
        
        - cleanUVs : cuv                 (bool)          [create,query,edit]
            If true, the operation will look for and delete UVs that are not associated with
            any face in the mesh.
        
        - cleanVertices : cv             (bool)          [create,query,edit]
            If true, the operation will look for and delete vertices that are not associated
            with any face in the mesh.
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          [create,query,edit]
            Toggle frozen state for a particular node to keep current evaluation state and
            prevent any other indirect changes to it.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyClean`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Noise(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Color(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RebuildSurface(AbstractBaseNurbsConversion):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getDegreeU(self, **kwargs):
        """
        The degree of the resulting surface in the u direction 0 - maintain current, 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getDegreeV(self, **kwargs):
        """
        The degree of the resulting surface in the v direction 0 - maintain current, 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getDirection(self, **kwargs):
        """
        The direction in which to rebuild: 0 - U, 1 - V, 2 - Both U and V Default:2                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getEndKnots(self, **kwargs):
        """
        End conditions for the surface 0 - uniform end knots, 1 - multiple end knots, Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getFitRebuild(self, **kwargs):
        """
        Specify the type of rebuild method to be used: 0 - Convert Classic, the default and original convert method. 1 - Fit using the least squares fit method. 2 - Convert Match, alternate matching convert method. 3 - Convert Grid, uses a grid-based fit algorithm. Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getKeepControlPoints(self, **kwargs):
        """
        Use the control points of the input surface. This forces uniform parameterization unless rebuildType is 2 (match knots) Default:false                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getKeepCorners(self, **kwargs):
        """
        The corners of the resulting surface will not change from the corners of the input surface. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getKeepRange(self, **kwargs):
        """
        Determine the parameterization for the resulting surface. 0 - reparameterize the resulting surface from 0 to 1; 1 - keep the original surface parameterization; 2 - reparameterize the result from 0 to number of spans Default:1                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getRebuildType(self, **kwargs):
        """
        The rebuild type: 0 - uniform, 1 - reduce spans, 2 - match knots, 3 - remove multiple knots, 4 - force non rational 5 - rebuild ends 6 - trim convert (uniform) 7 - into Bezier mesh Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getSpansU(self, **kwargs):
        """
        The number of spans in the u direction in resulting surface. Used only when rebuildType is 0 - uniform. If 0, keep the same number of spans as the original surface. Default:4                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getSpansV(self, **kwargs):
        """
        The number of spans in the v direction in resulting surface. Used only when rebuildType is 0 - uniform. If 0, keep the same number of spans as the original surface. Default:4                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to rebuild Default:0.01                  Common flags
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setDegreeU(self, val='True', **kwargs):
        """
        The degree of the resulting surface in the u direction 0 - maintain current, 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setDegreeV(self, val='True', **kwargs):
        """
        The degree of the resulting surface in the v direction 0 - maintain current, 1 - linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        The direction in which to rebuild: 0 - U, 1 - V, 2 - Both U and V Default:2                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setEndKnots(self, val='True', **kwargs):
        """
        End conditions for the surface 0 - uniform end knots, 1 - multiple end knots, Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setFitRebuild(self, val='True', **kwargs):
        """
        Specify the type of rebuild method to be used: 0 - Convert Classic, the default and original convert method. 1 - Fit using the least squares fit method. 2 - Convert Match, alternate matching convert method. 3 - Convert Grid, uses a grid-based fit algorithm. Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setKeepControlPoints(self, val='True', **kwargs):
        """
        Use the control points of the input surface. This forces uniform parameterization unless rebuildType is 2 (match knots) Default:false                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setKeepCorners(self, val='True', **kwargs):
        """
        The corners of the resulting surface will not change from the corners of the input surface. Default:true                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setKeepRange(self, val='True', **kwargs):
        """
        Determine the parameterization for the resulting surface. 0 - reparameterize the resulting surface from 0 to 1; 1 - keep the original surface parameterization; 2 - reparameterize the result from 0 to number of spans Default:1                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setRebuildType(self, val='True', **kwargs):
        """
        The rebuild type: 0 - uniform, 1 - reduce spans, 2 - match knots, 3 - remove multiple knots, 4 - force non rational 5 - rebuild ends 6 - trim convert (uniform) 7 - into Bezier mesh Default:0                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setSpansU(self, val='True', **kwargs):
        """
        The number of spans in the u direction in resulting surface. Used only when rebuildType is 0 - uniform. If 0, keep the same number of spans as the original surface. Default:4                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setSpansV(self, val='True', **kwargs):
        """
        The number of spans in the v direction in resulting surface. Used only when rebuildType is 0 - uniform. If 0, keep the same number of spans as the original surface. Default:4                  
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to rebuild Default:0.01                  Common flags
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command rebuilds a surface by modifying its parameterization. In some cases
        the shape of the surface may also change. The rebuildType (-rt) attribute
        determines how the surface is rebuilt. The optional second surface can be used
        to specify a reference parameterization.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degreeU : du                   (int)           [create,query,edit]
            The degree of the resulting surface in the u direction 0 - maintain current, 1 -
            linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3
        
        - degreeV : dv                   (int)           [create,query,edit]
            The degree of the resulting surface in the v direction 0 - maintain current, 1 -
            linear, 2 - quadratic, 3 - cubic, 5 - quintic, 7 - heptic Default:3
        
        - direction : dir                (int)           [create,query,edit]
            The direction in which to rebuild: 0 - U, 1 - V, 2 - Both U and V Default:2
        
        - endKnots : end                 (int)           [create,query,edit]
            End conditions for the surface 0 - uniform end knots, 1 - multiple end knots,
            Default:0
        
        - fitRebuild : fr                (int)           [create,query,edit]
            Specify the type of rebuild method to be used: 0 - Convert Classic, the default
            and original convert method. 1 - Fit using the least squares fit method. 2 -
            Convert Match, alternate matching convert method. 3 - Convert Grid, uses a grid-
            based fit algorithm. Default:0
        
        - frozen : fzn                   (bool)          []
        
        - keepControlPoints : kcp        (bool)          [create,query,edit]
            Use the control points of the input surface. This forces uniform
            parameterization unless rebuildType is 2 (match knots) Default:false
        
        - keepCorners : kc               (bool)          [create,query,edit]
            The corners of the resulting surface will not change from the corners of the
            input surface. Default:true
        
        - keepRange : kr                 (int)           [create,query,edit]
            Determine the parameterization for the resulting surface. 0 - reparameterize the
            resulting surface from 0 to 1; 1 - keep the original surface parameterization; 2
            - reparameterize the result from 0 to number of spans Default:1
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - noChanges : nc                 (bool)          []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)
        
        - rebuildType : rt               (int)           [create,query,edit]
            The rebuild type: 0 - uniform, 1 - reduce spans, 2 - match knots, 3 - remove
            multiple knots, 4 - force non rational 5 - rebuild ends 6 - trim convert
            (uniform) 7 - into Bezier mesh Default:0
        
        - replaceOriginal : rpo          (bool)          [create]
            Create in place(i.e., replace).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - spansU : su                    (int)           [create,query,edit]
            The number of spans in the u direction in resulting surface. Used only when
            rebuildType is 0 - uniform. If 0, keep the same number of spans as the original
            surface. Default:4
        
        - spansV : sv                    (int)           [create,query,edit]
            The number of spans in the v direction in resulting surface. Used only when
            rebuildType is 0 - uniform. If 0, keep the same number of spans as the original
            surface. Default:4
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to rebuild Default:0.01                  Common flags
        
        
        Derived from mel command `maya.cmds.rebuildSurface`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyColorPerVertex(PolyModifier):
    def getAlpha(self, **kwargs):
        """
        Specifies the alpha channel of color                               
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getClamped(self, **kwargs):
        """
        This flag specifies if the color set will truncate any value that is outside 0 to 1 range.                                 
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getColorB(self, **kwargs):
        """
        Specifies the B channel of color                                   
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getColorDisplayOption(self, **kwargs):
        """
        Change the display options on the mesh to display the vertex colors.                               
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getColorG(self, **kwargs):
        """
        Specifies the G channel of color                                   
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getColorR(self, **kwargs):
        """
        Specifies the R channel of color                                   
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getColorRGB(self, **kwargs):
        """
        Specifies the RGB channels of color                                
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getNotUndoable(self, **kwargs):
        """
        Execute the command, but without having the command be undoable. This option will greatly improve performance for large numbers of object. This will make the command not undoable regardless of whether undo has been enabled or not.                             
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getRelative(self, **kwargs):
        """
        When used, the color values specified are added relative to the current values.                                    
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getRemove(self, **kwargs):
        """
        When used, the color values are removed from the selected or specified objects or components. This option only supports meshes with no construction history, or meshes whose construction history includes a recent polyColorPerVertexNode. For meshes whose construction history includes a polgon operation the polyColorPerVertexNode, consider using the polyColorDel command instead                                  
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def getRepresentation(self, **kwargs):
        """
        This flag corresponds to the color channels to used, for example A(alpha only), RGB, and RGBA.                             Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setAlpha(self, val='True', **kwargs):
        """
        Specifies the alpha channel of color                               
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setClamped(self, val='True', **kwargs):
        """
        This flag specifies if the color set will truncate any value that is outside 0 to 1 range.                                 
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setColorB(self, val='True', **kwargs):
        """
        Specifies the B channel of color                                   
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setColorDisplayOption(self, val='True', **kwargs):
        """
        Change the display options on the mesh to display the vertex colors.                               
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setColorG(self, val='True', **kwargs):
        """
        Specifies the G channel of color                                   
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setColorR(self, val='True', **kwargs):
        """
        Specifies the R channel of color                                   
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setColorRGB(self, val='True', **kwargs):
        """
        Specifies the RGB channels of color                                
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setNotUndoable(self, val='True', **kwargs):
        """
        Execute the command, but without having the command be undoable. This option will greatly improve performance for large numbers of object. This will make the command not undoable regardless of whether undo has been enabled or not.                             
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setRelative(self, val='True', **kwargs):
        """
        When used, the color values specified are added relative to the current values.                                    
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setRemove(self, val='True', **kwargs):
        """
        When used, the color values are removed from the selected or specified objects or components. This option only supports meshes with no construction history, or meshes whose construction history includes a recent polyColorPerVertexNode. For meshes whose construction history includes a polgon operation the polyColorPerVertexNode, consider using the polyColorDel command instead                                  
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    def setRepresentation(self, val='True', **kwargs):
        """
        This flag corresponds to the color channels to used, for example A(alpha only), RGB, and RGBA.                             Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command associates color(rgb and alpha) with vertices on polygonal objects. When
        used with the query flag, it returns the color associated with the specified
        components.
        
        Flags:
        - alpha : a                      (float)         [create,query,edit]
            Specifies the alpha channel of color
        
        - clamped : cla                  (bool)          [create,query,edit]
            This flag specifies if the color set will truncate any value that is outside 0
            to 1 range.
        
        - colorB : b                     (float)         [create,query,edit]
            Specifies the B channel of color
        
        - colorDisplayOption : cdo       (bool)          [create,query,edit]
            Change the display options on the mesh to display the vertex colors.
        
        - colorG : g                     (float)         [create,query,edit]
            Specifies the G channel of color
        
        - colorR : r                     (float)         [create,query,edit]
            Specifies the R channel of color
        
        - colorRGB : rgb                 (float, float, float) [create,query,edit]
            Specifies the RGB channels of color
        
        - notUndoable : nun              (bool)          [create,query,edit]
            Execute the command, but without having the command be undoable. This option
            will greatly improve performance for large numbers of object. This will make the
            command not undoable regardless of whether undo has been enabled or not.
        
        - relative : rel                 (bool)          [create,query,edit]
            When used, the color values specified are added relative to the current values.
        
        - remove : rem                   (bool)          [create,query,edit]
            When used, the color values are removed from the selected or specified objects
            or components. This option only supports meshes with no construction history, or
            meshes whose construction history includes a recent polyColorPerVertexNode. For
            meshes whose construction history includes a polgon operation the
            polyColorPerVertexNode, consider using the polyColorDel command instead
        
        - representation : rpt           (int)           [create,query,edit]
            This flag corresponds to the color channels to used, for example A(alpha only),
            RGB, and RGBA.                             Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyColorPerVertex`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Grid(Texture2d):
    def getDefault(self, **kwargs):
        """
        Used to specify/query default values.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getDisplayAxes(self, **kwargs):
        """
        Specify true to display the grid axes.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getDisplayAxesBold(self, **kwargs):
        """
        Specify true to accent the grid axes by drawing them with a thicker line.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getDisplayDivisionLines(self, **kwargs):
        """
        Specify true to display the subdivision lines between grid lines.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getDisplayGridLines(self, **kwargs):
        """
        Specify true to display the grid lines.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getDisplayOrthographicLabels(self, **kwargs):
        """
        Specify true to display the grid line numeric labels in the orthographic views.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getDisplayPerspectiveLabels(self, **kwargs):
        """
        Specify true to display the grid line numeric labels in the perspective view.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getDivisions(self, **kwargs):
        """
        Sets the number of subdivisions between major grid lines. The default is 5. If the spacing is 5 units, setting divisions to 5 will cause division lines to appear 1 unit apart.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getOrthographicLabelPosition(self, **kwargs):
        """
        The position of the grid's numeric labels in orthographic views. Valid values are    axisand edge.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getPerspectiveLabelPosition(self, **kwargs):
        """
        The position of the grid's numeric labels in perspective views. Valid values are    axisand edge.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getSize(self, **kwargs):
        """
        Sets the size of the grid in linear units.  The default is 12 units.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getSpacing(self, **kwargs):
        """
        Sets the spacing between major grid lines in linear units. The default is 5 units.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getStyle(self, **kwargs):
        """
        This flag is obsolete and should not be used.                  
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    def getToggle(self, **kwargs):
        """
        Turns the ground plane display off in all windows, including orthographic windows.  Default is true.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command changes the size and spacing of lines on the ground plane displayed
        in the perspective and orthographic views. This command lets you reset the
        ground plane, change its size and grid line spacing, grid subdivisions and
        display options. In query mode, return type is based on queried flag.
        
        Flags:
        - default : df                   (bool)          [query]
            Used to specify/query default values.
        
        - displayAxes : da               (bool)          [query]
            Specify true to display the grid axes.
        
        - displayAxesBold : dab          (bool)          [query]
            Specify true to accent the grid axes by drawing them with a thicker line.
        
        - displayDivisionLines : ddl     (bool)          [query]
            Specify true to display the subdivision lines between grid lines.
        
        - displayGridLines : dgl         (bool)          [query]
            Specify true to display the grid lines.
        
        - displayOrthographicLabels : dol (bool)          [query]
            Specify true to display the grid line numeric labels in the orthographic views.
        
        - displayPerspectiveLabels : dpl (bool)          [query]
            Specify true to display the grid line numeric labels in the perspective view.
        
        - divisions : d                  (int)           [query]
            Sets the number of subdivisions between major grid lines. The default is 5. If
            the spacing is 5 units, setting divisions to 5 will cause division lines to
            appear 1 unit apart.
        
        - orthographicLabelPosition : olp (unicode)       [query]
            The position of the grid's numeric labels in orthographic views. Valid values
            are    axisand edge.
        
        - perspectiveLabelPosition : plp (unicode)       [query]
            The position of the grid's numeric labels in perspective views. Valid values are
            axisand edge.
        
        - reset : r                      (bool)          []
            Resets the ground plane to its default values
        
        - size : s                       (float)         [query]
            Sets the size of the grid in linear units.  The default is 12 units.
        
        - spacing : sp                   (float)         [query]
            Sets the spacing between major grid lines in linear units. The default is 5
            units.
        
        - style : st                     (int)           [query]
            This flag is obsolete and should not be used.
        
        - toggle : tgl                   (bool)          [query]
            Turns the ground plane display off in all windows, including orthographic
            windows.  Default is true.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.grid`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Python(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DagNode(Entity):
    def __apihandle__(self):
        """
        get the ``maya.OpenMaya.MObjectHandle`` for this node if it is valid
        """
        pass
    def __apimdagpath__(self):
        """
        get the ``maya.OpenMaya.MDagPath`` for this object if it is valid
        """
        pass
    def __apiobject__(self):
        """
        get the ``maya.OpenMaya.MDagPath`` for this object if it is valid
        """
        pass
    def __or__(self, child, **kwargs):
        """
        operator for `addChild`. Use to easily daisy-chain together parenting operations.
        The operation order visually mimics the resulting dag path:
        
            >>> from pymel.core import *
            >>> s = polySphere(name='sphere')[0]
            >>> c = polyCube(name='cube')[0]
            >>> t = polyTorus(name='torus')[0]
            >>> s | c | t
            nt.Transform(u'torus')
            >>> print t.fullPath()
            |sphere|cube|torus
        
        Returns
        -------
        DagNode
        """
        pass
    def activeColor(self):
        """
        Determines the active color used by this node. The active color is the active color for this kind of dag node.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.activeColor`
        """
        pass
    def addChild(self, child, **kwargs):
        """
        parent (reversed)
        
        Returns
        -------
        DagNode
        """
        pass
    def boundingBox(self):
        """
        Returns the bounding box for the dag node in object space.
        
        Returns:
        'BoundingBox'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.boundingBox`
        """
        pass
    def child(self, i):
        """
        Queries the DAG Node attached to the Function Set for the child Node corresponding to the given index.
        
        Parameters:
        i : 'int'
            Index to the child Node
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.child`
        
        Aliases: child, childAtIndex
        """
        pass
    def childAtIndex(self, i):
        """
        Queries the DAG Node attached to the Function Set for the child Node corresponding to the given index.
        
        Parameters:
        i : 'int'
            Index to the child Node
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.child`
        
        Aliases: child, childAtIndex
        """
        pass
    def childCount(self):
        """
        Determines the number of child Nodes of the Node. Used to determine the upper bound for the child index (max index = childCount-1).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.childCount`
        
        Aliases: childCount, numChildren
        """
        pass
    def comp(self, compName):
        """
        Will retrieve a Component object for this node; similar to
        DependNode.attr(), but for components.
        
        Returns
        -------
        general.Component
        """
        pass
    def dagRoot(self):
        """
        Determines the root of the first DAG Path to the DAG Node attached to the Function Set.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.dagRoot`
        
        Aliases: dagRoot, root
        """
        pass
    def dormantColor(self):
        """
        Determines the dormant color used by this node. The order to determine the dormant color is:
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.dormantColor`
        """
        pass
    def drawOverrideColor(self):
        """
        Determines the draw override color used by this node. Returns true if there is a draw override color. Otherwise, returns false and color parameter is not changed.
        
        Returns:
        Tuple['bool', 'Color']
        
        Derived from api method `maya.OpenMaya.MFnDagNode.drawOverrideColor`
        """
        pass
    def drawOverrideEnabled(self):
        """
        Determines whether or not draw override is turned on for this node.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.drawOverrideEnabled`
        """
        pass
    def drawOverrideIsReference(self):
        """
        Determines whether or not Display Type of the draw override is Reference for this node.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.drawOverrideIsReference`
        """
        pass
    def drawOverrideIsTemplate(self):
        """
        Determines whether or not Display Type of the draw override is Template for this node.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.drawOverrideIsTemplate`
        """
        pass
    def firstParent(self):
        """
        firstParentOf
        
        Returns
        -------
        DagNode
        """
        pass
    def firstParent2(self, **kwargs):
        """
        unlike the firstParent command which determines the parent via string formatting, this
        command uses the listRelatives command
        """
        pass
    def fullPath(self, **kwargs):
        """
        The full dag path to the object, including leading pipe ( | )
        
        Returns
        -------
        unicode
        
        Examples
        --------
        >>> import pymel.core as pm
        >>> pm.newFile(f=1)
        ''
        >>> cube1 = pm.polyCube()[0]
        >>> cube2 = pm.polyCube()[0]
        >>> cube3 = pm.polyCube()[0]
        >>> cube3Shape = cube3.getShape()
        
        >>> cube2.setParent(cube1)
        nt.Transform(u'pCube2')
        >>> cube3.setParent(cube2)
        nt.Transform(u'pCube3')
        
        >>> pm.namespace(add='foo')
        u'foo'
        >>> pm.namespace(add='bar', parent='foo')
        u'foo:bar'
        >>> pm.namespace(add='stuff', parent='foo:bar')
        u'foo:bar:stuff'
        
        >>> cube2.rename(':foo:pCube2')
        nt.Transform(u'foo:pCube2')
        >>> cube3.rename(':foo:bar:pCube3')
        nt.Transform(u'foo:bar:pCube3')
        >>> cube3Shape.rename(':foo:bar:stuff:pCubeShape3')
        nt.Mesh(u'foo:bar:stuff:pCubeShape3')
        
        >>> cube3Shape.longName()
        u'|pCube1|foo:pCube2|foo:bar:pCube3|foo:bar:stuff:pCubeShape3'
        >>> cube3Shape.longName(stripNamespace=True)
        u'|pCube1|pCube2|pCube3|pCubeShape3'
        >>> cube3Shape.longName(stripNamespace=True, levels=1)
        u'|pCube1|pCube2|bar:pCube3|bar:stuff:pCubeShape3'
        >>> cube3Shape.longName(stripNamespace=True, levels=2)
        u'|pCube1|pCube2|pCube3|stuff:pCubeShape3'
        
        >>> cam = pm.camera()[0]
        >>> cam.setParent(cube2)
        nt.Transform(u'camera1')
        >>> imagePlane = pm.imagePlane(camera=cam.getShape())[1]
        >>> imagePlane.rename('foo:bar:stuff:imagePlaneShape1')
        nt.ImagePlane(u'cameraShape1->foo:bar:stuff:imagePlaneShape1')
        
        >>> imagePlane.longName()
        u'|pCube1|foo:pCube2|camera1|cameraShape1->|imagePlane1|foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.longName(stripUnderWorld=True)
        u'|imagePlane1|foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.longName(stripNamespace=True, levels=1)
        u'|pCube1|pCube2|camera1|cameraShape1->|imagePlane1|bar:stuff:imagePlaneShape1'
        >>> imagePlane.longName(stripUnderWorld=True, stripNamespace=True)
        u'|imagePlane1|imagePlaneShape1'
        """
        pass
    def fullPathName(self):
        """
        Return a string representing the full path from the root of the dag to this object.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.fullPathName`
        """
        pass
    def getAllParents(self):
        """
        Return a list of all parents above this.
        
        Starts from the parent immediately above, going up.
        
        Returns
        -------
        List[DagNode]
        """
        pass
    def getAllPaths(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getInstances instead.
        """
        pass
    def getChildren(self, **kwargs):
        """
        see also `childAtIndex`
        
        for flags, see ``pymel.core.general.listRelatives``
        
        Returns
        -------
        List[DagNode]
        """
        pass
    def getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly):
        """
        Returns all the sets connected to the specified instance of this DAG object. For each set in the "sets" array there is a corresponding entry in the "comps" array which are all the components in that set. If the entire object is in a set, then the corresponding entry in the comps array will have no elements in it.
        
        Parameters:
        instanceNumber : 'int'
            The instance number of the mesh to query
        renderableSetsOnly : 'bool'
            If true then this method will only return renderable sets
        
        
        Returns:
        Tuple[List['PyNode'], List['PyNode']]
        
        Derived from api method `maya.OpenMaya.MFnDagNode.getConnectedSetsAndMembers`
        """
        pass
    def getInstances(self, includeSelf='True'):
        """
        Returns
        -------
        List[DagNode]
        
        Examples
        --------
        >>> from pymel.core import *
        >>> f=newFile(f=1) #start clean
        >>>
        >>> s = polyPlane()[0]
        >>> instance(s)
        [nt.Transform(u'pPlane2')]
        >>> instance(s)
        [nt.Transform(u'pPlane3')]
        >>> s.getShape().getInstances()
        [nt.Mesh(u'pPlane1|pPlaneShape1'), nt.Mesh(u'pPlane2|pPlaneShape1'), nt.Mesh(u'pPlane3|pPlaneShape1')]
        >>> s.getShape().getInstances(includeSelf=False)
        [nt.Mesh(u'pPlane2|pPlaneShape1'), nt.Mesh(u'pPlane3|pPlaneShape1')]
        """
        pass
    def getObjectColor(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    def getObjectColorType(self):
        """
        Determines whether or not the user defined inactive color will be used for the node, or whether the default inactive color will be used.
        
        Returns:
        'DagNode.MObjectColorType'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.objectColorType`
        """
        pass
    def getOtherInstances(self):
        """
        same as `DagNode.getInstances` with includeSelf=False.
        
        Returns
        -------
        List[DagNode]
        """
        pass
    def getParent(self, generations='1'):
        """
        Modifications:
            - added optional generations flag, which gives the number of levels up that you wish to go for the parent;
              ie:
                  >>> from pymel.core import *
                  >>> select(cl=1)
                  >>> bottom = group(n='bottom')
                  >>> group(n='almostThere')
                  nt.Transform(u'almostThere')
                  >>> group(n='nextLevel')
                  nt.Transform(u'nextLevel')
                  >>> group(n='topLevel')
                  nt.Transform(u'topLevel')
                  >>> bottom.longName()
                  u'|topLevel|nextLevel|almostThere|bottom'
                  >>> bottom.getParent(2)
                  nt.Transform(u'nextLevel')
        
              Negative values will traverse from the top:
        
                  >>> bottom.getParent(generations=-3)
                  nt.Transform(u'almostThere')
        
              A value of 0 will return the same node.
              The default value is 1.
        
              If generations is None, it will be interpreted as 'return all
              parents', and a list will be returned.
        
              Since the original command returned None if there is no parent, to sync with this behavior, None will
              be returned if generations is out of bounds (no IndexError will be thrown).
        
        Returns
        -------
        Optional[DagNode]
        """
        pass
    def getSiblings(self, **kwargs):
        """
        for flags, see ``pymel.core.general.listRelatives``
        
        Returns
        -------
        List[DagNode]
        """
        pass
    def hasChild(self, child):
        """
        Modifications:
        - handles underworld nodes correctly
        """
        pass
    def hasParent(self, parent):
        """
        Modifications:
        - handles underworld nodes correctly
        """
        pass
    def hide(self): pass
    def hiliteColor(self):
        """
        Determines the current hilite color used by the node.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.hiliteColor`
        """
        pass
    def inModel(self):
        """
        Determines whether or not the DAG Node is in the model.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.inModel`
        """
        pass
    def inUnderWorld(self):
        """
        Determines whether or not the DAG Node is an underworld node. (An example of an underworld node is a curve on surface.)
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.inUnderWorld`
        """
        pass
    def instanceCount(self, total='True'):
        """
        Determines the number of times the Node attached to the Function Set is instanced.
        
        Parameters:
        total : 'bool'
            Indirect instance flag
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.instanceCount`
        """
        pass
    def instanceNumber(self):
        """
        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.
        
        Returns
        -------
        int
        """
        pass
    def isChildOf(self, parent):
        """
        Modifications:
        - handles underworld nodes correctly
        """
        pass
    def isDisplaced(self):
        """
        Returns whether any of this object's shading groups have a
        displacement shader input
        
        Returns
        -------
        bool
        """
        pass
    def isInstanceOf(self, other):
        """
        Returns
        -------
        bool
        """
        pass
    def isInstanceable(self):
        """
        Returns true if the DAG node can be instanced, and false otherwise.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.isInstanceable`
        """
        pass
    def isInstanced(self, indirect='True'):
        """
        Determines whether the DAG Node attached to the Function Set is directly or indirectly instanced.
        
        Parameters:
        indirect : 'bool'
            Indirect instance flag
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.isInstanced`
        """
        pass
    def isInstancedAttribute(self, attribute):
        """
        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.
        
        Parameters:
        attribute : 'PyNode'
            The attribute to test.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.isInstancedAttribute`
        """
        pass
    def isIntermediate(self):
        """
        Returns true if this object is an intermediate in a geometry calculation.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.isIntermediateObject`
        
        Aliases: isIntermediate, isIntermediateObject
        """
        pass
    def isIntermediateObject(self):
        """
        Returns true if this object is an intermediate in a geometry calculation.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.isIntermediateObject`
        
        Aliases: isIntermediate, isIntermediateObject
        """
        pass
    def isParentOf(self, child):
        """
        Modifications:
        - handles underworld nodes correctly
        """
        pass
    def isUsingObjectColor(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    def isVisible(self, checkOverride='True'): pass
    def listComp(self, names='False'):
        """
        Will return a list of all component objects for this object
        
        Is to .comp() what .listAttr() is to .attr(); will NOT check the shape
        node.
        
        Parameters
        ----------
        names : bool
            By default, will return a list of actual usabale pymel Component
            objects; if you just want a list of string names which would
            be compatible with .comp(), set names to True
        """
        pass
    def listRelatives(self, **kwargs):
        """
        for flags, see ``pymel.core.general.listRelatives``
        
        Returns
        -------
        List[DagNode]
        """
        pass
    def longName(self, **kwargs):
        """
        The full dag path to the object, including leading pipe ( | )
        
        Returns
        -------
        unicode
        
        Examples
        --------
        >>> import pymel.core as pm
        >>> pm.newFile(f=1)
        ''
        >>> cube1 = pm.polyCube()[0]
        >>> cube2 = pm.polyCube()[0]
        >>> cube3 = pm.polyCube()[0]
        >>> cube3Shape = cube3.getShape()
        
        >>> cube2.setParent(cube1)
        nt.Transform(u'pCube2')
        >>> cube3.setParent(cube2)
        nt.Transform(u'pCube3')
        
        >>> pm.namespace(add='foo')
        u'foo'
        >>> pm.namespace(add='bar', parent='foo')
        u'foo:bar'
        >>> pm.namespace(add='stuff', parent='foo:bar')
        u'foo:bar:stuff'
        
        >>> cube2.rename(':foo:pCube2')
        nt.Transform(u'foo:pCube2')
        >>> cube3.rename(':foo:bar:pCube3')
        nt.Transform(u'foo:bar:pCube3')
        >>> cube3Shape.rename(':foo:bar:stuff:pCubeShape3')
        nt.Mesh(u'foo:bar:stuff:pCubeShape3')
        
        >>> cube3Shape.longName()
        u'|pCube1|foo:pCube2|foo:bar:pCube3|foo:bar:stuff:pCubeShape3'
        >>> cube3Shape.longName(stripNamespace=True)
        u'|pCube1|pCube2|pCube3|pCubeShape3'
        >>> cube3Shape.longName(stripNamespace=True, levels=1)
        u'|pCube1|pCube2|bar:pCube3|bar:stuff:pCubeShape3'
        >>> cube3Shape.longName(stripNamespace=True, levels=2)
        u'|pCube1|pCube2|pCube3|stuff:pCubeShape3'
        
        >>> cam = pm.camera()[0]
        >>> cam.setParent(cube2)
        nt.Transform(u'camera1')
        >>> imagePlane = pm.imagePlane(camera=cam.getShape())[1]
        >>> imagePlane.rename('foo:bar:stuff:imagePlaneShape1')
        nt.ImagePlane(u'cameraShape1->foo:bar:stuff:imagePlaneShape1')
        
        >>> imagePlane.longName()
        u'|pCube1|foo:pCube2|camera1|cameraShape1->|imagePlane1|foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.longName(stripUnderWorld=True)
        u'|imagePlane1|foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.longName(stripNamespace=True, levels=1)
        u'|pCube1|pCube2|camera1|cameraShape1->|imagePlane1|bar:stuff:imagePlaneShape1'
        >>> imagePlane.longName(stripUnderWorld=True, stripNamespace=True)
        u'|imagePlane1|imagePlaneShape1'
        """
        pass
    def makeLive(self, state='True'): pass
    def name(self, update='True', long='False', stripNamespace='False', levels='0', stripUnderWorld='False'):
        """
        The name of the node
        
        Parameters
        ----------
        update : bool
            if True, will always query to underlying maya object to get it's
            current name (and will therefore detect renames, re-parenting, etc);
            if False, it will use a cached value if available (which is slightly
            faster, but may be out of date)
        long : Optional[bool]
            if True, will include always include the full dag path, starting
            from the world root, including leading pipe ( | ); if False, will
            return the shortest-unique path; if None, node names will always be
            returned without any parents, if if they are not unique
        stripNamespace : bool
            if True, all nodes will have their namespaces stipped off of them
            (or a certain number of them, if levels is also used)
        levels : int
            if stripNamespace is True, then this number will determine the how
            many namespaces will be removed; if 0 (the default), then all
            leading namespaces will be removed; otherwise, this value gives the
            number of left-most levels to strip
        stripUnderWorld : bool
            if stripUnderWorld is True, and the name has underworld components
            (ie, topNode|topNodeShape->underWorld|underWorldShape), then only
            the portion in the "deepest underworld" is returned (ie,
            underWorld|underWorldShape)
        
        
        Returns
        -------
        unicode
        
        
        Examples
        --------
        >>> import pymel.core as pm
        >>> pm.newFile(f=1)
        ''
        >>> cube1 = pm.polyCube()[0]
        >>> cube2 = pm.polyCube()[0]
        >>> cube3 = pm.polyCube()[0]
        >>> cube3Shape = cube3.getShape()
        
        >>> cube2.setParent(cube1)
        nt.Transform(u'pCube2')
        >>> cube3.setParent(cube2)
        nt.Transform(u'pCube3')
        
        >>> pm.namespace(add='foo')
        u'foo'
        >>> pm.namespace(add='bar', parent='foo')
        u'foo:bar'
        >>> pm.namespace(add='stuff', parent='foo:bar')
        u'foo:bar:stuff'
        
        >>> cube2.rename(':foo:pCube2')
        nt.Transform(u'foo:pCube2')
        >>> cube3.rename(':foo:bar:pCube3')
        nt.Transform(u'foo:bar:pCube3')
        >>> cube3Shape.rename(':foo:bar:stuff:pCubeShape3')
        nt.Mesh(u'foo:bar:stuff:pCubeShape3')
        
        >>> cube3Shape.name()
        u'foo:bar:stuff:pCubeShape3'
        >>> cube3Shape.name(stripNamespace=True)
        u'pCubeShape3'
        >>> cube3Shape.name(long=True)
        u'|pCube1|foo:pCube2|foo:bar:pCube3|foo:bar:stuff:pCubeShape3'
        >>> cube3Shape.name(long=True, stripNamespace=True)
        u'|pCube1|pCube2|pCube3|pCubeShape3'
        >>> cube3Shape.name(long=True, stripNamespace=True, levels=1)
        u'|pCube1|pCube2|bar:pCube3|bar:stuff:pCubeShape3'
        >>> cube3Shape.name(long=True, stripNamespace=True, levels=2)
        u'|pCube1|pCube2|pCube3|stuff:pCubeShape3'
        
        >>> cam = pm.camera()[0]
        >>> cam.setParent(cube2)
        nt.Transform(u'camera1')
        >>> imagePlane = pm.imagePlane(camera=cam.getShape())[1]
        >>> imagePlane.rename('foo:bar:stuff:imagePlaneShape1')
        nt.ImagePlane(u'cameraShape1->foo:bar:stuff:imagePlaneShape1')
        
        >>> imagePlane.name()
        u'cameraShape1->foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.name(stripUnderWorld=True)
        u'foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.name(stripNamespace=True, levels=1)
        u'cameraShape1->bar:stuff:imagePlaneShape1'
        >>> imagePlane.name(stripUnderWorld=True, long=True)
        u'|imagePlane1|foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.name(stripUnderWorld=True, stripNamespace=True, long=True)
        u'|imagePlane1|imagePlaneShape1'
        """
        pass
    def nodeName(self, stripUnderWorld='True', **kwargs):
        """
        Just the name of the node, without any dag path
        
        Returns
        -------
        unicode
        
        Examples
        --------
        >>> import pymel.core as pm
        >>> pm.newFile(f=1)
        ''
        >>> cube1 = pm.polyCube()[0]
        >>> cube2 = pm.polyCube()[0]
        >>> cube3 = pm.polyCube()[0]
        >>> cube3Shape = cube3.getShape()
        
        >>> cube2.setParent(cube1)
        nt.Transform(u'pCube2')
        >>> cube3.setParent(cube2)
        nt.Transform(u'pCube3')
        
        >>> pm.namespace(add='foo')
        u'foo'
        >>> pm.namespace(add='bar', parent='foo')
        u'foo:bar'
        >>> pm.namespace(add='stuff', parent='foo:bar')
        u'foo:bar:stuff'
        
        >>> cube2.rename(':foo:pCube2')
        nt.Transform(u'foo:pCube2')
        >>> cube3.rename(':foo:bar:pCube3')
        nt.Transform(u'foo:bar:pCube3')
        >>> cube3Shape.rename(':foo:bar:stuff:pCubeShape3')
        nt.Mesh(u'foo:bar:stuff:pCubeShape3')
        
        >>> # create an object with the same name as pCube3 / pCube4
        >>> cube3Twin = pm.polyCube()[0]
        >>> cube3Twin.rename('foo:bar:pCube3')
        nt.Transform(u'|foo:bar:pCube3')
        >>> cube3ShapeTwin = cube3Twin.getShape()
        >>> cube3ShapeTwin.rename('foo:bar:stuff:pCubeShape3')
        nt.Mesh(u'|foo:bar:pCube3|foo:bar:stuff:pCubeShape3')
        
        >>> cube3Shape.shortName()
        u'foo:pCube2|foo:bar:pCube3|foo:bar:stuff:pCubeShape3'
        >>> cube3Shape.nodeName()
        u'foo:bar:stuff:pCubeShape3'
        >>> cube3Shape.nodeName(stripNamespace=True)
        u'pCubeShape3'
        >>> cube3Shape.nodeName(stripNamespace=True, levels=1)
        u'bar:stuff:pCubeShape3'
        >>> cube3Shape.nodeName(stripNamespace=True, levels=2)
        u'stuff:pCubeShape3'
        
        >>> cam = pm.camera()[0]
        >>> cam.setParent(cube2)
        nt.Transform(u'camera1')
        >>> imagePlaneTrans, imagePlane = pm.imagePlane(camera=cam.getShape())
        >>> imagePlane.rename('foo:bar:stuff:imagePlaneShape1')
        nt.ImagePlane(u'cameraShape1->foo:bar:stuff:imagePlaneShape1')
        
        >>> # create an object with the same name as cam
        >>> pm.camera()[0].setParent(cube3Twin).rename('camera1')
        nt.Transform(u'|foo:bar:pCube3|camera1')
        
        >>> # create an object with the same name as imagePlane
        >>> imagePlaneTwinTrans, imagePlaneTwin = pm.imagePlane(camera=cam.getShape())
        >>> imagePlaneTwin.rename('foo:bar:stuff:imagePlaneShape1')
        nt.ImagePlane(u'foo:pCube2|camera1|cameraShape1->imagePlane2|foo:bar:stuff:imagePlaneShape1')
        
        >>> imagePlane.shortName()
        u'foo:pCube2|camera1|cameraShape1->imagePlane1|foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.nodeName()
        u'foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.nodeName(stripUnderWorld=False)
        u'cameraShape1->foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.nodeName(stripNamespace=True)
        u'imagePlaneShape1'
        >>> imagePlane.nodeName(stripNamespace=True, levels=1)
        u'bar:stuff:imagePlaneShape1'
        """
        pass
    def numChildren(self):
        """
        Determines the number of child Nodes of the Node. Used to determine the upper bound for the child index (max index = childCount-1).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.childCount`
        
        Aliases: childCount, numChildren
        """
        pass
    def objectColorIndex(self):
        """
        Determines the index for the current user defined inactive color used by the node. Valid indices are from 0 to 7.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.objectColorIndex`
        """
        pass
    def objectColorRGB(self):
        """
        Determines the RGB color for the current user defined inactive color used by the node.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.objectColorRGB`
        """
        pass
    def objectGroupComponent(self, groupId, compList):
        """
        Parameters:
        groupId : 'int'
            
        compList : List['list']
            
        
        Derived from api method `maya.OpenMaya.MFnDagNode.objectGroupComponent`
        """
        pass
    def parent(self, i):
        """
        Queries the DAG Node attached to the Function Set for the parent Node corresponding to the given index.
        
        Parameters:
        i : 'int'
            Index to the parent Node
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.parent`
        
        Aliases: parent, parentAtIndex
        """
        pass
    def parentAtIndex(self, i):
        """
        Queries the DAG Node attached to the Function Set for the parent Node corresponding to the given index.
        
        Parameters:
        i : 'int'
            Index to the parent Node
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.parent`
        
        Aliases: parent, parentAtIndex
        """
        pass
    def parentCount(self):
        """
        Determines the number of parent Nodes of the Node. Used to determine the upper bound for the parent index (max index = parentCount-1).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.parentCount`
        """
        pass
    def partialPathName(self):
        """
        Return a string representing the partial path from the root of the dag to this object.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.partialPathName`
        """
        pass
    def root(self):
        """
        Determines the root of the first DAG Path to the DAG Node attached to the Function Set.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.dagRoot`
        
        Aliases: dagRoot, root
        """
        pass
    def setInstanceable(self, how):
        """
        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.
        
        Parameters:
        how : 'bool'
            true if the node should be made instanceable, false to make the node noninstanceable.
        
        Derived from api method `maya.OpenMaya.MFnDagNode.setInstanceable`
        """
        pass
    def setIntermediate(self, isIntermediate):
        """
        Sets whether this object is an intermediate in a geometry calculation.
        
        Parameters:
        isIntermediate : 'bool'
            whether to make this an intermediate object
        
        Derived from api method `maya.OpenMaya.MFnDagNode.setIntermediateObject`
        
        Aliases: setIntermediate, setIntermediateObject
        """
        pass
    def setIntermediateObject(self, isIntermediate):
        """
        Sets whether this object is an intermediate in a geometry calculation.
        
        Parameters:
        isIntermediate : 'bool'
            whether to make this an intermediate object
        
        Derived from api method `maya.OpenMaya.MFnDagNode.setIntermediateObject`
        
        Aliases: setIntermediate, setIntermediateObject
        """
        pass
    def setObjectColor(self, color='None'):
        """
        This command sets the dormant wireframe color of the specified objects
        to an integer representing one of the user defined colors, or, if set
        to None, to the default class color
        """
        pass
    def setObjectColorType(self, type):
        """
        Sets whether or not the user defined inactive object color will be used.
        
        Parameters:
        type : 'DagNode.MObjectColorType'
            MFnDagNode::kUseDefaultColor - the color defined in the color preferences will be used. MFnDagNode::kUseIndexColor - the user-defined inactive object indexed color will be used MFnDagNode::kUseRGBColor - the user defined inactive RGB object color will be used
        
            values: 'defaultColor', 'indexColor', 'RGBColor'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.setObjectColorType`
        """
        pass
    def setParent(self, *args, **kwargs):
        """
        parent
        
        Modifications:
            - if parent is 'None', world=True is automatically set
            - if the given parent is the current parent, don't error
        """
        pass
    def setUseObjectColor(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    def shortName(self, **kwargs):
        """
        The shortest unique name.
        
        Returns
        -------
        unicode
        
        Examples
        --------
        >>> import pymel.core as pm
        >>> pm.newFile(f=1)
        ''
        >>> cube1 = pm.polyCube()[0]
        >>> cube2 = pm.polyCube()[0]
        >>> cube3 = pm.polyCube()[0]
        >>> cube3Shape = cube3.getShape()
        
        >>> cube2.setParent(cube1)
        nt.Transform(u'pCube2')
        >>> cube3.setParent(cube2)
        nt.Transform(u'pCube3')
        
        >>> pm.namespace(add='foo')
        u'foo'
        >>> pm.namespace(add='bar', parent='foo')
        u'foo:bar'
        >>> pm.namespace(add='stuff', parent='foo:bar')
        u'foo:bar:stuff'
        
        >>> cube2.rename(':foo:pCube2')
        nt.Transform(u'foo:pCube2')
        >>> cube3.rename(':foo:bar:pCube3')
        nt.Transform(u'foo:bar:pCube3')
        >>> cube3Shape.rename(':foo:bar:stuff:pCubeShape3')
        nt.Mesh(u'foo:bar:stuff:pCubeShape3')
        
        >>> cube3Shape.shortName()
        u'foo:bar:stuff:pCubeShape3'
        >>> cube3Shape.shortName(stripNamespace=True)
        u'pCubeShape3'
        >>> cube3Shape.shortName(stripNamespace=True, levels=1)
        u'bar:stuff:pCubeShape3'
        >>> cube3Shape.shortName(stripNamespace=True, levels=2)
        u'stuff:pCubeShape3'
        
        >>> cam = pm.camera()[0]
        >>> cam.setParent(cube2)
        nt.Transform(u'camera1')
        >>> imagePlane = pm.imagePlane(camera=cam.getShape())[1]
        >>> imagePlane.rename('foo:bar:stuff:imagePlaneShape1')
        nt.ImagePlane(u'cameraShape1->foo:bar:stuff:imagePlaneShape1')
        
        >>> imagePlane.shortName()
        u'cameraShape1->foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.shortName(stripUnderWorld=True)
        u'foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.shortName(stripNamespace=True, levels=1)
        u'cameraShape1->bar:stuff:imagePlaneShape1'
        >>> imagePlane.shortName(stripUnderWorld=True)
        u'foo:bar:stuff:imagePlaneShape1'
        >>> imagePlane.shortName(stripUnderWorld=True, stripNamespace=True)
        u'imagePlaneShape1'
        """
        pass
    def show(self): pass
    def transformationMatrix(self):
        """
        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.
        
        Returns:
        'Matrix'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.transformationMatrix`
        """
        pass
    def usingHiliteColor(self):
        """
        Determines whether or not the hilite color will be used for the node. hilite command sets this flag to true.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDagNode.usingHiliteColor`
        """
        pass
    def usingObjectColor(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    MObjectColorType = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Ramp(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyTweakUV(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Time(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierNoise(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyAppendVertex(PolyModifier):
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyAppendVertex`
        """
        pass
    def getTexture(self, **kwargs):
        """
        Specifies how new faces are mapped. 0 - None; 1 - Normalize; 2 - Unitize C: Default is 0 (no mapping). Q: When queried, this flag returns an int
        
        
        Derived from mel command `maya.cmds.polyAppendVertex`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        Specifies how new faces are mapped. 0 - None; 1 - Normalize; 2 - Unitize C: Default is 0 (no mapping). Q: When queried, this flag returns an int
        
        
        Derived from mel command `maya.cmds.polyAppendVertex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Appends a new face to the selected polygonal object. The direction of the normal
        is given by the vertex order: the face normal points towards the user when the
        vertices rotate counter clockwise. Note that holes must be described in the
        opposite direction. Only works with one object selected.
        
        Flags:
        - append : a                     (float, float, float) [create]
            Append a vertex or a point to the selected object, or mark the start of a hole.
            This flag may also be used in place of the hole, vertexand pointflags. If no
            argument is passed to the appendflag, then it marks the beginning of a hole (use
            an empty tuple in Python '()').  If one argument is passed, then the argument is
            considered to be an index into the vertices of the selected object, as with the
            vertexflag.  If three arguments are passed, then it is interpreted as the
            coordinates of a new point which will be inserted, as with the pointflag.
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - hole : h                       (bool)          [create]
            Add a hole. The following points and edges will define a hole.  Note that this
            flag should be avoided in Python.  You may use the appendflag instead and pass
            an empty tuple '()' to specify the start of a hole.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - point : p                      (float, float, float) [create]
            Adds a new point to the new face. Coordinates of free points are given in the
            local object reference.  Note that this flag should be avoided in Python.  You
            may use the appendflag instead and pass three arguments.
        
        - texture : tx                   (int)           [create,query,edit]
            Specifies how new faces are mapped. 0 - None; 1 - Normalize; 2 - Unitize C:
            Default is 0 (no mapping). Q: When queried, this flag returns an int
        
        - vertex : v                     (int)           [create]
            Adds the given vertex of the selected object to the new face.  Note that this
            flag should be avoided in Python.  You may use the appendflag instead and pass
            one argument.                  Flag can have multiple arguments, passed either
            as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyAppendVertex`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Stencil(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyConnectComponents(PolyModifier):
    def getAdjustEdgeFlow(self, **kwargs):
        """
        The weight value of the edge vertices to be positioned.                  
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def getInsertWithEdgeFlow(self, **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled.                  
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def setAdjustEdgeFlow(self, val='True', **kwargs):
        """
        The weight value of the edge vertices to be positioned.                  
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def setInsertWithEdgeFlow(self, val='True', **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled.                  
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Splits polygon edges according to the selected components. The selected
        components are gathered into connected 'paths' that define continuous splits.
        Mixed components (vertices, edges and faces) can be used at once. The connection
        rules are: \* Edges can connect to other edges in the same face or to vertices
        in the same face (that are not in the edge itself) or to faces connected to
        other edges in the same face. \* Vertices can connect to edges (as above) or to
        vertices in the same face (that are not joined to the first vertex by an edge)
        or to faces adjacent to a face that uses the vertex (except those that also use
        the vertex). \* Faces can connect to vertices or edges (as above) or to adjacent
        faces.
        
        Flags:
        - adjustEdgeFlow : aef           (float)         [create,query,edit]
            The weight value of the edge vertices to be positioned.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - insertWithEdgeFlow : ief       (bool)          [create,query,edit]
            True to enable edge flow. Otherwise, the edge flow is disabled.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyConnectComponents`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Water(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySmoothFace(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Signal(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierGuide(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySmoothProxy(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class IkRPsolver(IkSCsolver):
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierSculpt(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Ocean(Texture2d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySpinEdge(PolyModifier):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - caching : cch                  (bool)          []
        
        - constructionHistory : ch       (bool)          []
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           []
        
        - offset : off                   (int)           []
        
        - reverse : rev                  (bool)          []
        
        
        Derived from mel command `maya.cmds.polySpinEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmModifierDisplacement(XgmModifierBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMergeFace(PolyModifier):
    __melnode__ = []
    
    
    __readonly__ = {}


class Stucco(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_ChannelRandom(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyRelOverride(ApplyOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyDelVertex(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDelVertex`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyDelVertex`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDelVertex`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDelVertex`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDelVertex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Deletes vertices. Joins two edges which have a common vertex. The vertices must
        be connected to exactly two edges (so-called winged).
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyDelVertex`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdMapCut(SubdModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.subdMapCut`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.subdMapCut`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.subdMapCut`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.subdMapCut`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Cut along edges of the texture mapping. The cut edges become map borders.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.subdMapCut`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_DynamicsInitialState(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Mute(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyFlipEdge(PolyModifier):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command to flip the edges shared by 2 adjacent triangles. When used with the
        edit flag, new edges can be added to the same node, instead of creating a
        separate node in the chain.
        
        
        Derived from mel command `maya.cmds.polyFlipEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Offset(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvCube(TextureEnv):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMergeEdge(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def getFirstEdge(self, **kwargs):
        """
        First edge to merge. Invalid default value to force the value to be set. Default:-1                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def getMergeMode(self, **kwargs):
        """
        Merge mode : 0=first, 1=halfway between both edges, 2=second. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def getMergeTexture(self, **kwargs):
        """
        Boolean which is used to decide if uv coordinates should be merged or not - along with the geometry. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def getSecondEdge(self, **kwargs):
        """
        Second edge to merge. Invalid default value to force the value to be set. Default:-1                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def setFirstEdge(self, val='True', **kwargs):
        """
        First edge to merge. Invalid default value to force the value to be set. Default:-1                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def setMergeMode(self, val='True', **kwargs):
        """
        Merge mode : 0=first, 1=halfway between both edges, 2=second. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def setMergeTexture(self, val='True', **kwargs):
        """
        Boolean which is used to decide if uv coordinates should be merged or not - along with the geometry. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    def setSecondEdge(self, val='True', **kwargs):
        """
        Second edge to merge. Invalid default value to force the value to be set. Default:-1                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Sews two border edges together.The new edge is located either on the first,
        last, or between both selected edges, depending on the mode. Both edges must
        belong to the same object, and orientations must match (i.e. normals on
        corresponding faces must point in the same direction).Edge flags are mandatory.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - firstEdge : fe                 (int)           [create,query,edit]
            First edge to merge. Invalid default value to force the value to be set.
            Default:-1
        
        - frozen : fzn                   (bool)          []
        
        - mergeMode : mm                 (int)           [create,query,edit]
            Merge mode : 0=first, 1=halfway between both edges, 2=second. Default:1
        
        - mergeTexture : mt              (bool)          [create,query,edit]
            Boolean which is used to decide if uv coordinates should be merged or not -
            along with the geometry. Default:false
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - secondEdge : se                (int)           [create,query,edit]
            Second edge to merge. Invalid default value to force the value to be set.
            Default:-1                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMergeEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Projection(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Strength(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMapSew(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapSew`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMapSew`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapSew`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapSew`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapSew`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Sew border edges in texture space. Selected edges must be map borders.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMapSew`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class QuadShadingSwitch(BaseShadingSwitch):
    __melnode__ = []
    
    
    __readonly__ = {}


class AISEnvFacade(EnvFacade):
    __melnode__ = []
    
    
    __readonly__ = {}


class Cloud(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCreateFace(PolyCreator):
    __melnode__ = []
    
    
    __readonly__ = {}


class SimpleSelector(Selector):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyConnectionOverride(ApplyOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MpBirailSrf(BirailSrf):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Noise(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Granite(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Random(MASH_BaseNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyDelEdge(PolyModifier):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    def getCleanVertices(self, **kwargs):
        """
        If on : delete resulting winged vertices. C: Default is off. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    def setCleanVertices(self, val='True', **kwargs):
        """
        If on : delete resulting winged vertices. C: Default is off. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Deletes selected edges, and merges neighboring faces. If deletion leaves winged
        vertices, they may be deleted as well. Notice : only non border edges can be
        deleted.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - cleanVertices : cv             (bool)          [create,query,edit]
            If on : delete resulting winged vertices. C: Default is off. Q: When queried,
            this flag returns an int.
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyDelEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Crater(Texture3d):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyHoleFace(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromSurfaceBnd(CurveFromSurface):
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleSystem(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_BlendDeformer(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OffsetDeformer(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromSurfaceIso(CurveFromSurface):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyBridgeEdge(PolyModifierWorld):
    def getBridgeOffset(self, **kwargs):
        """
        Add offset to which vertices are connected. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getCurveType(self, **kwargs):
        """
        Format: 0 - Linear, 1 - Blend, 2 - Curve Default:TdnpolyBridgeEdge::Linear                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getDivisions(self, **kwargs):
        """
        The number of subdivisions in the bridging faces (resulting in (divisions+1) row of faces). Default:1                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getSmoothingAngle(self, **kwargs):
        """
        Angle below which new edges will be smoothed Default:kPi/6.0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getStartVert1(self, **kwargs):
        """
        The start vertex from the first set of edges Default:-1                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getStartVert2(self, **kwargs):
        """
        The start vertex from the second set of edges Default:-1                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getTaper(self, **kwargs):
        """
        Taper or Scale along the extrusion path Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getTaperCurve_FloatValue(self, **kwargs):
        """
        Value for taperCurve; Curve control for taper along extrusion Using this curve, the taper along extrusion can be changed from a simple linear scaling to custom scaling along the extrusion path.                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getTaperCurve_Interp(self, **kwargs):
        """
        Interpolation type for taperCurve; Curve control for taper along extrusion Using this curve, the taper along extrusion can be changed from a simple linear scaling to custom scaling along the extrusion path.                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getTaperCurve_Position(self, **kwargs):
        """
        Position for taperCurve; Curve control for taper along extrusion Using this curve, the taper along extrusion can be changed from a simple linear scaling to custom scaling along the extrusion path.                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getTwist(self, **kwargs):
        """
        Twist or Rotation along the extrusion path Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setBridgeOffset(self, val='True', **kwargs):
        """
        Add offset to which vertices are connected. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setCurveType(self, val='True', **kwargs):
        """
        Format: 0 - Linear, 1 - Blend, 2 - Curve Default:TdnpolyBridgeEdge::Linear                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setDivisions(self, val='True', **kwargs):
        """
        The number of subdivisions in the bridging faces (resulting in (divisions+1) row of faces). Default:1                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setSmoothingAngle(self, val='True', **kwargs):
        """
        Angle below which new edges will be smoothed Default:kPi/6.0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setStartVert1(self, val='True', **kwargs):
        """
        The start vertex from the first set of edges Default:-1                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setStartVert2(self, val='True', **kwargs):
        """
        The start vertex from the second set of edges Default:-1                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setTaper(self, val='True', **kwargs):
        """
        Taper or Scale along the extrusion path Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setTaperCurve_FloatValue(self, val='True', **kwargs):
        """
        Value for taperCurve; Curve control for taper along extrusion Using this curve, the taper along extrusion can be changed from a simple linear scaling to custom scaling along the extrusion path.                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setTaperCurve_Interp(self, val='True', **kwargs):
        """
        Interpolation type for taperCurve; Curve control for taper along extrusion Using this curve, the taper along extrusion can be changed from a simple linear scaling to custom scaling along the extrusion path.                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setTaperCurve_Position(self, val='True', **kwargs):
        """
        Position for taperCurve; Curve control for taper along extrusion Using this curve, the taper along extrusion can be changed from a simple linear scaling to custom scaling along the extrusion path.                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setTwist(self, val='True', **kwargs):
        """
        Twist or Rotation along the extrusion path Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Bridges two sets of edges.
        
        Flags:
        - bridgeOffset : bo              (int)           [create,query,edit]
            Add offset to which vertices are connected. Default:0
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - curveType : ctp                (int)           [create,query,edit]
            Format: 0 - Linear, 1 - Blend, 2 - Curve Default:TdnpolyBridgeEdge::Linear
        
        - direction : d                  (int)           []
        
        - divisions : dv                 (int)           [create,query,edit]
            The number of subdivisions in the bridging faces (resulting in (divisions+1) row
            of faces). Default:1
        
        - frozen : fzn                   (bool)          []
        
        - inputCurve : inc               (PyNode)        [create]
            This flag specifies the name of the curve to be used as input for the operation.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - reverse : rev                  (bool)          []
        
        - smoothingAngle : sma           (float)         [create,query,edit]
            Angle below which new edges will be smoothed Default:kPi/6.0
        
        - sourceDirection : sd           (int)           []
        
        - startVert1 : sv1               (int)           [create,query,edit]
            The start vertex from the first set of edges Default:-1
        
        - startVert2 : sv2               (int)           [create,query,edit]
            The start vertex from the second set of edges Default:-1
        
        - taper : tp                     (float)         [create,query,edit]
            Taper or Scale along the extrusion path Default:1.0
        
        - taperCurve_FloatValue : cfv    (float)         [create,query,edit]
            Value for taperCurve; Curve control for taper along extrusion Using this curve,
            the taper along extrusion can be changed from a simple linear scaling to custom
            scaling along the extrusion path.
        
        - taperCurve_Interp : ci         (int)           [create,query,edit]
            Interpolation type for taperCurve; Curve control for taper along extrusion Using
            this curve, the taper along extrusion can be changed from a simple linear
            scaling to custom scaling along the extrusion path.
        
        - taperCurve_Position : cp       (float)         [create,query,edit]
            Position for taperCurve; Curve control for taper along extrusion Using this
            curve, the taper along extrusion can be changed from a simple linear scaling to
            custom scaling along the extrusion path.
        
        - targetDirection : td           (int)           []
        
        - twist : twt                    (float)         [create,query,edit]
            Twist or Rotation along the extrusion path Default:0.0
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyBridgeEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AovChildCollection(Collection):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class KeyingGroup(ObjectSet):
    def addElement(self, val='True', **kwargs):
        """
        Adds the list of items to the given set.  If some of the items cannot be added to the set because they are in another set which is in the same partition as the set to edit, the command will fail.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def afterFilters(self, val='True', **kwargs):
        """
        Default state is false. This flag is valid in edit mode only. This flag is for use on sets that are acted on by deformers such as sculpt, lattice, blendShape. The default edit mode is to edit the membership of the group acted on by the deformer. If you want to edit the group but not change the membership of the deformer, set the flag to true.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def flatten(self, val='True', **kwargs):
        """
        An operation that flattens the structure of the given set. That is, any sets contained by the given set will be replaced by its members so that the set no longer contains other sets but contains the other sets' members.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getActivator(self, **kwargs):
        """
        Sets the selected node(s) as activators for the given keying group. In query mode, returns list of objects that activate the given keying group                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getCategory(self, **kwargs):
        """
        Sets the keying group's category. This is what the global, active keying group filter will use to match.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getColor(self, **kwargs):
        """
        Defines the hilite color of the set. Must be a value in range [-1, 7] (one of the user defined colors).  -1 marks the color has being undefined and therefore not having any affect. Only the vertices of a vertex set will be displayed in this color.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getEdges(self, **kwargs):
        """
        Indicates the new set can contain edges only. This flag is for use in creation or query mode only. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getEditPoints(self, **kwargs):
        """
        Indicates the new set can contain editPoints only. This flag is for use in creation or query mode only. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getFacets(self, **kwargs):
        """
        Indicates the new set can contain facets only. This flag is for use in creation or query mode only. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getMinimizeRotation(self, **kwargs):
        """
        This flag only affects the attribute contained in the immediate keyingGroup. It does not affect attributes in sub-keyingGroups. Those will need to set minimizeRotation on their respective keyingGroups                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getNodesOnly(self, **kwargs):
        """
        This flag is usable with the -q/query flag but is ignored if used with another queryable flags. This flag modifies the results of the set membership query such that when there are attributes (e.g. sphere1.tx) or components of nodes included in the set, only the nodes will be listed. Each node will only be listed once, even if more than one attribute or component of the node exists in the set.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getRenderable(self, **kwargs):
        """
        This flag indicates that a special type of set should be created. This type of set (shadingEngine as opposed to objectSet) has certain restrictions on its membership in that it can only contain renderable elements such as lights and geometry. These sets are referred to as shading groups and are automatically connected to the renderPartitionnode when created (to ensure mutual exclusivity of the set's members with the other sets in the partition). This flag is for use in creation or query mode only. The default value is false which means a normal set is created.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getSetActiveFilter(self, **kwargs):
        """
        Sets the global, active keying group filter, which will affect activation of keying groups. Only keying groups with categories that match the filter will be activated. If the setActiveFilter is set to NoKeyingGroups, keying groups will not be activated at all. If the setActiveFilter is set to AllKeyingGroups, we will activate any keying group rather than just those with matching categories.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getSize(self, **kwargs):
        """
        Use the size flag to query the length of the set.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getText(self, **kwargs):
        """
        Defines an annotation string to be stored with the set.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def getVertices(self, **kwargs):
        """
        Indicates the new set can contain vertices only. This flag is for use in creation or query mode only. The default value is false.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def include(self, val='True', **kwargs):
        """
        Adds the list of items to the given set.  If some of the items cannot be added to the set, a warning will be issued. This is a less strict version of the -add/addElement operation.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def removeActivator(self, val='True', **kwargs):
        """
        Removes the selected node(s) as activators for the given keying group.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def setActivator(self, val='True', **kwargs):
        """
        Sets the selected node(s) as activators for the given keying group. In query mode, returns list of objects that activate the given keying group                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def setCategory(self, val='True', **kwargs):
        """
        Sets the keying group's category. This is what the global, active keying group filter will use to match.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def setColor(self, val='True', **kwargs):
        """
        Defines the hilite color of the set. Must be a value in range [-1, 7] (one of the user defined colors).  -1 marks the color has being undefined and therefore not having any affect. Only the vertices of a vertex set will be displayed in this color.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def setMinimizeRotation(self, val='True', **kwargs):
        """
        This flag only affects the attribute contained in the immediate keyingGroup. It does not affect attributes in sub-keyingGroups. Those will need to set minimizeRotation on their respective keyingGroups                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def setSetActiveFilter(self, val='True', **kwargs):
        """
        Sets the global, active keying group filter, which will affect activation of keying groups. Only keying groups with categories that match the filter will be activated. If the setActiveFilter is set to NoKeyingGroups, keying groups will not be activated at all. If the setActiveFilter is set to AllKeyingGroups, we will activate any keying group rather than just those with matching categories.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        Defines an annotation string to be stored with the set.                  
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to manage the membership of a keying group.  Keying groups
        allow users to effectively manage related keyframe data, allowing keys on
        attributes in the keying group to be set and edited as a single entity.
        
        Flags:
        - activator : act                (PyNode)        [query,edit]
            Sets the selected node(s) as activators for the given keying group. In query
            mode, returns list of objects that activate the given keying group
        
        - addElement : add               (PyNode)        [edit]
            Adds the list of items to the given set.  If some of the items cannot be added
            to the set because they are in another set which is in the same partition as the
            set to edit, the command will fail.
        
        - afterFilters : af              (bool)          [edit]
            Default state is false. This flag is valid in edit mode only. This flag is for
            use on sets that are acted on by deformers such as sculpt, lattice, blendShape.
            The default edit mode is to edit the membership of the group acted on by the
            deformer. If you want to edit the group but not change the membership of the
            deformer, set the flag to true.
        
        - category : cat                 (unicode)       [create,query,edit]
            Sets the keying group's category. This is what the global, active keying group
            filter will use to match.
        
        - clear : cl                     (PyNode)        [edit]
            An operation which removes all items from the given set making the set empty.
        
        - color : co                     (int)           [create,query,edit]
            Defines the hilite color of the set. Must be a value in range [-1, 7] (one of
            the user defined colors).  -1 marks the color has being undefined and therefore
            not having any affect. Only the vertices of a vertex set will be displayed in
            this color.
        
        - copy : cp                      (PyNode)        [create]
            Copies the members of the given set to a new set. This flag is for use in
            creation mode only.
        
        - edges : eg                     (bool)          [create,query]
            Indicates the new set can contain edges only. This flag is for use in creation
            or query mode only. The default value is false.
        
        - editPoints : ep                (bool)          [create,query]
            Indicates the new set can contain editPoints only. This flag is for use in
            creation or query mode only. The default value is false.
        
        - empty : em                     (bool)          [create]
            Indicates that the set to be created should be empty. That is, it ignores any
            arguments identifying objects to be added to the set. This flag is only valid
            for operations that create a new set.
        
        - excludeDynamic : ed            (bool)          [create]
            When creating the keying group, exclude dynamic attributes.
        
        - excludeRotate : er             (bool)          [create]
            When creating the keying group, exclude rotate attributes from transform-type
            nodes.
        
        - excludeScale : es              (bool)          [create]
            When creating the keying group, exclude scale attributes from transform-type
            nodes.
        
        - excludeTranslate : et          (bool)          [create]
            When creating the keying group, exclude translate attributes from transform-type
            nodes. For example, if your keying group contains joints only, perhaps you only
            want to include rotations in the keying group.
        
        - excludeVisibility : ev         (bool)          [create]
            When creating the keying group, exclude visibility attribute from transform-type
            nodes.
        
        - facets : fc                    (bool)          [create,query]
            Indicates the new set can contain facets only. This flag is for use in creation
            or query mode only. The default value is false.
        
        - flatten : fl                   (PyNode)        [edit]
            An operation that flattens the structure of the given set. That is, any sets
            contained by the given set will be replaced by its members so that the set no
            longer contains other sets but contains the other sets' members.
        
        - forceElement : fe              (PyNode)        [edit]
            For use in edit mode only. Forces addition of the items to the set. If the items
            are in another set which is in the same partition as the given set, the items
            will be removed from the other set in order to keep the sets in the partition
            mutually exclusive with respect to membership.
        
        - include : include              (PyNode)        [edit]
            Adds the list of items to the given set.  If some of the items cannot be added
            to the set, a warning will be issued. This is a less strict version of the
            -add/addElement operation.
        
        - intersection : int             (PyNode)        [create]
            An operation that returns a list of items which are members of all the sets in
            the list.
        
        - isIntersecting : ii            (PyNode)        [create]
            An operation which tests whether the sets in the list have common members.
        
        - isMember : im                  (PyNode)        [create]
            An operation which tests whether all the given items are members of the given
            set.
        
        - layer : l                      (bool)          [create]
            OBSOLETE. DO NOT USE.
        
        - minimizeRotation : mr          (bool)          [create,query,edit]
            This flag only affects the attribute contained in the immediate keyingGroup. It
            does not affect attributes in sub-keyingGroups. Those will need to set
            minimizeRotation on their respective keyingGroups
        
        - name : n                       (unicode)       [create]
            Assigns string as the name for a new set. This flag is only valid for operations
            that create a new set.
        
        - noSurfaceShader : nss          (bool)          [create]
            If set is renderable, do not connect it to the default surface shader.  Flag has
            no meaning or effect for non renderable sets. This flag is for use in creation
            mode only. The default value is false.
        
        - noWarnings : nw                (bool)          [create]
            Indicates that warning messages should not be reported such as when trying to
            add an invalid item to a set. (used by UI)
        
        - nodesOnly : no                 (bool)          [query]
            This flag is usable with the -q/query flag but is ignored if used with another
            queryable flags. This flag modifies the results of the set membership query such
            that when there are attributes (e.g. sphere1.tx) or components of nodes included
            in the set, only the nodes will be listed. Each node will only be listed once,
            even if more than one attribute or component of the node exists in the set.
        
        - remove : rm                    (PyNode)        [edit]
            Removes the list of items from the given set.
        
        - removeActivator : rac          (PyNode)        [edit]
            Removes the selected node(s) as activators for the given keying group.
        
        - renderable : r                 (bool)          [create,query]
            This flag indicates that a special type of set should be created. This type of
            set (shadingEngine as opposed to objectSet) has certain restrictions on its
            membership in that it can only contain renderable elements such as lights and
            geometry. These sets are referred to as shading groups and are automatically
            connected to the renderPartitionnode when created (to ensure mutual exclusivity
            of the set's members with the other sets in the partition). This flag is for use
            in creation or query mode only. The default value is false which means a normal
            set is created.
        
        - setActiveFilter : fil          (unicode)       [create,query,edit]
            Sets the global, active keying group filter, which will affect activation of
            keying groups. Only keying groups with categories that match the filter will be
            activated. If the setActiveFilter is set to NoKeyingGroups, keying groups will
            not be activated at all. If the setActiveFilter is set to AllKeyingGroups, we
            will activate any keying group rather than just those with matching categories.
        
        - size : s                       (bool)          [query]
            Use the size flag to query the length of the set.
        
        - split : sp                     (PyNode)        [create]
            Produces a new set with the list of items and removes each item in the list of
            items from the given set.
        
        - subtract : sub                 (PyNode)        [create]
            An operation between two sets which returns the members of the first set that
            are not in the second set.
        
        - text : t                       (unicode)       [create,query,edit]
            Defines an annotation string to be stored with the set.
        
        - union : un                     (PyNode)        [create]
            An operation that returns a list of all the members of all sets listed.
        
        - vertices : v                   (bool)          [create,query]
            Indicates the new set can contain vertices only. This flag is for use in
            creation or query mode only. The default value is false.                  Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.keyingGroup`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyBevel(PolyModifierWorld):
    def getAngleTolerance(self, **kwargs):
        """
        Angular tolerance for creation of extra triangles Note this attribute is for compatability only and should not be modified in Maya 7.0 files Default:20.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getAutoFit(self, **kwargs):
        """
        If autoFit is on, it computes a smooth roundness :  new facets round off a smooth angle. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getMergeVertexTolerance(self, **kwargs):
        """
        Tolerance within which to merge vertices Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getMergeVertices(self, **kwargs):
        """
        Merge vertices within a tolerance Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getMiteringAngle(self, **kwargs):
        """
        Miter faces that have angles less than this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getOffset(self, **kwargs):
        """
        The offset for bevel. Default:0.2                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getOffsetAsFraction(self, **kwargs):
        """
        If on, the offset value is treated as a fraction between zero and one. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getRoundness(self, **kwargs):
        """
        The roundness of bevel, it is taken into account when autoFit is off. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getSegments(self, **kwargs):
        """
        The number of segments used for beveling. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getSmoothingAngle(self, **kwargs):
        """
        Create new edges as hard edges if the angle between adjacent faces exceeds this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getSubdivideNgons(self, **kwargs):
        """
        Subdivide new faces with more than 4 edges Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getUseLegacyBevelAlgorithm(self, **kwargs):
        """
        If on, bevel is done the way maya 2014 did Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getUvAssignment(self, **kwargs):
        """
        Technique used to compute UVs on new faces 0 computes new UVs by projecting along surface normal of original mesh onto new mesh 1 computes new UVs by projecting along surface normal of new mesh onto original mesh Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setAngleTolerance(self, val='True', **kwargs):
        """
        Angular tolerance for creation of extra triangles Note this attribute is for compatability only and should not be modified in Maya 7.0 files Default:20.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setAutoFit(self, val='True', **kwargs):
        """
        If autoFit is on, it computes a smooth roundness :  new facets round off a smooth angle. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setMergeVertexTolerance(self, val='True', **kwargs):
        """
        Tolerance within which to merge vertices Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setMergeVertices(self, val='True', **kwargs):
        """
        Merge vertices within a tolerance Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setMiteringAngle(self, val='True', **kwargs):
        """
        Miter faces that have angles less than this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        The offset for bevel. Default:0.2                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setOffsetAsFraction(self, val='True', **kwargs):
        """
        If on, the offset value is treated as a fraction between zero and one. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setRoundness(self, val='True', **kwargs):
        """
        The roundness of bevel, it is taken into account when autoFit is off. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setSegments(self, val='True', **kwargs):
        """
        The number of segments used for beveling. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setSmoothingAngle(self, val='True', **kwargs):
        """
        Create new edges as hard edges if the angle between adjacent faces exceeds this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setSubdivideNgons(self, val='True', **kwargs):
        """
        Subdivide new faces with more than 4 edges Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setUseLegacyBevelAlgorithm(self, val='True', **kwargs):
        """
        If on, bevel is done the way maya 2014 did Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setUvAssignment(self, val='True', **kwargs):
        """
        Technique used to compute UVs on new faces 0 computes new UVs by projecting along surface normal of original mesh onto new mesh 1 computes new UVs by projecting along surface normal of new mesh onto original mesh Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Bevel edges.
        
        Flags:
        - angleTolerance : at            (float)         [create,query,edit]
            Angular tolerance for creation of extra triangles Note this attribute is for
            compatability only and should not be modified in Maya 7.0 files Default:20.0
        
        - autoFit : af                   (bool)          [create,query,edit]
            If autoFit is on, it computes a smooth roundness :  new facets round off a
            smooth angle. Default:true
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - fillNgons : fn                 (bool)          []
        
        - fraction : f                   (float)         []
        
        - frozen : fzn                   (bool)          []
        
        - maya2015 : m15                 (bool)          []
        
        - mergeVertexTolerance : mvt     (float)         [create,query,edit]
            Tolerance within which to merge vertices Default:0.0
        
        - mergeVertices : mv             (bool)          [create,query,edit]
            Merge vertices within a tolerance Default:false
        
        - miteringAngle : ma             (float)         [create,query,edit]
            Miter faces that have angles less than this value Default:0.0
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - offset : o                     (float)         [create,query,edit]
            The offset for bevel. Default:0.2
        
        - offsetAsFraction : oaf         (bool)          [create,query,edit]
            If on, the offset value is treated as a fraction between zero and one.
            Default:false
        
        - roundness : r                  (float)         [create,query,edit]
            The roundness of bevel, it is taken into account when autoFit is off.
            Default:0.5
        
        - segments : sg                  (int)           [create,query,edit]
            The number of segments used for beveling. Default:1
        
        - smoothingAngle : sa            (float)         [create,query,edit]
            Create new edges as hard edges if the angle between adjacent faces exceeds this
            value Default:0.0
        
        - subdivideNgons : sn            (bool)          [create,query,edit]
            Subdivide new faces with more than 4 edges Default:false
        
        - useLegacyBevelAlgorithm : com  (bool)          [create,query,edit]
            If on, bevel is done the way maya 2014 did Default:false
        
        - uvAssignment : ua              (int)           [create,query,edit]
            Technique used to compute UVs on new faces 0 computes new UVs by projecting
            along surface normal of original mesh onto new mesh 1 computes new UVs by
            projecting along surface normal of new mesh onto original mesh Default:0
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyBevel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderSettingsChildCollection(Collection):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySoftEdge(PolyModifierWorld):
    def getAngle(self, **kwargs):
        """
        Smoothing angle. C: Default is 30 degrees. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def setAngle(self, val='True', **kwargs):
        """
        Smoothing angle. C: Default is 30 degrees. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Selectively makes edges soft or hard. An edge will be made hard if the angle
        between two owning faces is sharper (larger) than the smoothing angle. An edge
        wil be made soft if the angle between two owning facets is flatter (smaller)
        than the smoothing angle.
        
        Flags:
        - angle : a                      (float)         [create,query,edit]
            Smoothing angle. C: Default is 30 degrees. Q: When queried, this flag returns a
            float.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polySoftEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCircularize(PolyModifierWorld):
    def getAlignment(self, **kwargs):
        """
        How the circle should be  oriented relative to the surface Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getEvenlyDistribute(self, **kwargs):
        """
        Should the point be evenly distributed around the circle Default:true                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getNormalOrientation(self, **kwargs):
        """
        What calculation to use to get circle plane normal Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getRadialOffset(self, **kwargs):
        """
        The amount the circle points should be translated along radius Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getSmoothingAngle(self, **kwargs):
        """
        The angle that decides which resulting faces are hard or soft Default:30.0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setAlignment(self, val='True', **kwargs):
        """
        How the circle should be  oriented relative to the surface Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setEvenlyDistribute(self, val='True', **kwargs):
        """
        Should the point be evenly distributed around the circle Default:true                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setNormalOrientation(self, val='True', **kwargs):
        """
        What calculation to use to get circle plane normal Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setRadialOffset(self, val='True', **kwargs):
        """
        The amount the circle points should be translated along radius Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setSmoothingAngle(self, val='True', **kwargs):
        """
        The angle that decides which resulting faces are hard or soft Default:30.0                  
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Mirror all the faces of the selected object.
        
        Flags:
        - alignment : al                 (int)           [create,query,edit]
            How the circle should be  oriented relative to the surface Default:0
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createCurve : cc               (bool)          [create]
            If true then the operation can create a curve.
        
        - divisions : d                  (int)           []
        
        - evenlyDistribute : ed          (bool)          [create,query,edit]
            Should the point be evenly distributed around the circle Default:true
        
        - frozen : fzn                   (bool)          []
        
        - inputCurve : inc               (PyNode)        [create]
            This flag specifies the name of the curve to be used as input for the operation.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - normalOffset : no              (float)         []
        
        - normalOrientation : nor        (int)           [create,query,edit]
            What calculation to use to get circle plane normal Default:0
        
        - radialOffset : ro              (float)         [create,query,edit]
            The amount the circle points should be translated along radius Default:0.0
        
        - relaxInterior : ri             (float)         []
        
        - smoothingAngle : sa            (float)         [create,query,edit]
            The angle that decides which resulting faces are hard or soft Default:30.0
        
        - supportingEdges : se           (int)           []
        
        - twist : t                      (float)         []
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCircularize`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySplitRing(PolyModifierWorld):
    def getAdjustEdgeFlow(self, **kwargs):
        """
        The weight value of the edge vertices to be positioned. Default:1.0f                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getDirection(self, **kwargs):
        """
        This attribute is used when doing an absolute split.  If true then the distance is taken from the start vertex of the root edge.  If false the distance is taken from the end vertext of the root edge. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getDivisions(self, **kwargs):
        """
        Number of divisions. Default:2                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getEnableProfileCurve(self, **kwargs):
        """
        Enables the use of the profile curve. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getFixQuads(self, **kwargs):
        """
        Fixes splits which go across a quad face leaving a 5 and 3 sided faces by splitting from the middle of the new edge to the vertex accross from the edge on the 5 sided face. Default:false                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getInsertWithEdgeFlow(self, **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled. Default:false                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getProfileCurveInputOffset(self, **kwargs):
        """
        Changes the offset to the multisplit profile curve. eg. if the profile curve values go between 0 and 1 and this value is set to -1 then the profile curves values will be adjusted to go between -1 and 0. Default:0.0f                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getProfileCurveInputScale(self, **kwargs):
        """
        Changes the range of values that the profile curve represents. eg. if the profile curve values go between 0 and 1 and this value is set to 2 then the profile curves values will be adjusted to go between 0 and 2. Default:1.0f                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getProfileCurve_FloatValue(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getProfileCurve_Interp(self, **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getProfileCurve_Position(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getRootEdge(self, **kwargs):
        """
        The weight attribute uses the start vertex of this edge to determine where the new split occurs. Default:-1                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getSmoothingAngle(self, **kwargs):
        """
        Angle below which new edges will be smoothed Default:kPi                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getSplitType(self, **kwargs):
        """
        Format: 0 - Absolute, 1 - Relative, 2 - Multi Default:TdnpolySplitRing::Relative                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getUseEqualMultiplier(self, **kwargs):
        """
        Changes how the profile curve effects the offset when doing a multisplit.  If true then the verts will be offset the same distance based on the shortest edge being split.  If false then each inserted edge loop will be offset a distance relative to the length of the edge that is being split. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getUseFaceNormalsAtEnds(self, **kwargs):
        """
        When doing a multisplit on a set of non-closed edge ring this will toggle the normals at the ends of the split to be calculated as the edge normal or the face normal. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getWeight(self, **kwargs):
        """
        Weight value controlling the relative positioning of the new points on existing edges. Range is [0.0, 1.0]. Value of 0.1 indicates the new edges will be placed closer to the start vertex of the first edge of the sequence of edges. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setAdjustEdgeFlow(self, val='True', **kwargs):
        """
        The weight value of the edge vertices to be positioned. Default:1.0f                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        This attribute is used when doing an absolute split.  If true then the distance is taken from the start vertex of the root edge.  If false the distance is taken from the end vertext of the root edge. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setDivisions(self, val='True', **kwargs):
        """
        Number of divisions. Default:2                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setEnableProfileCurve(self, val='True', **kwargs):
        """
        Enables the use of the profile curve. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setFixQuads(self, val='True', **kwargs):
        """
        Fixes splits which go across a quad face leaving a 5 and 3 sided faces by splitting from the middle of the new edge to the vertex accross from the edge on the 5 sided face. Default:false                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setInsertWithEdgeFlow(self, val='True', **kwargs):
        """
        True to enable edge flow. Otherwise, the edge flow is disabled. Default:false                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setProfileCurveInputOffset(self, val='True', **kwargs):
        """
        Changes the offset to the multisplit profile curve. eg. if the profile curve values go between 0 and 1 and this value is set to -1 then the profile curves values will be adjusted to go between -1 and 0. Default:0.0f                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setProfileCurveInputScale(self, val='True', **kwargs):
        """
        Changes the range of values that the profile curve represents. eg. if the profile curve values go between 0 and 1 and this value is set to 2 then the profile curves values will be adjusted to go between 0 and 2. Default:1.0f                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setProfileCurve_FloatValue(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setProfileCurve_Interp(self, val='True', **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setProfileCurve_Position(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setRootEdge(self, val='True', **kwargs):
        """
        The weight attribute uses the start vertex of this edge to determine where the new split occurs. Default:-1                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setSmoothingAngle(self, val='True', **kwargs):
        """
        Angle below which new edges will be smoothed Default:kPi                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setSplitType(self, val='True', **kwargs):
        """
        Format: 0 - Absolute, 1 - Relative, 2 - Multi Default:TdnpolySplitRing::Relative                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setUseEqualMultiplier(self, val='True', **kwargs):
        """
        Changes how the profile curve effects the offset when doing a multisplit.  If true then the verts will be offset the same distance based on the shortest edge being split.  If false then each inserted edge loop will be offset a distance relative to the length of the edge that is being split. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setUseFaceNormalsAtEnds(self, val='True', **kwargs):
        """
        When doing a multisplit on a set of non-closed edge ring this will toggle the normals at the ends of the split to be calculated as the edge normal or the face normal. Default:true                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setWeight(self, val='True', **kwargs):
        """
        Weight value controlling the relative positioning of the new points on existing edges. Range is [0.0, 1.0]. Value of 0.1 indicates the new edges will be placed closer to the start vertex of the first edge of the sequence of edges. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Splits a series of ring edges of connected quads and inserts connecting edges
        between them.
        
        Flags:
        - adjustEdgeFlow : aef           (float)         [create,query,edit]
            The weight value of the edge vertices to be positioned. Default:1.0f
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - direction : dr                 (bool)          [create,query,edit]
            This attribute is used when doing an absolute split.  If true then the distance
            is taken from the start vertex of the root edge.  If false the distance is taken
            from the end vertext of the root edge. Default:true
        
        - divisions : div                (int)           [create,query,edit]
            Number of divisions. Default:2
        
        - enableProfileCurve : epc       (bool)          [create,query,edit]
            Enables the use of the profile curve. Default:true
        
        - fixQuads : fq                  (bool)          [create,query,edit]
            Fixes splits which go across a quad face leaving a 5 and 3 sided faces by
            splitting from the middle of the new edge to the vertex accross from the edge on
            the 5 sided face. Default:false
        
        - frozen : fzn                   (bool)          []
        
        - insertWithEdgeFlow : ief       (bool)          [create,query,edit]
            True to enable edge flow. Otherwise, the edge flow is disabled. Default:false
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - profileCurveInputOffset : pio  (float)         [create,query,edit]
            Changes the offset to the multisplit profile curve. eg. if the profile curve
            values go between 0 and 1 and this value is set to -1 then the profile curves
            values will be adjusted to go between -1 and 0. Default:0.0f
        
        - profileCurveInputScale : pis   (float)         [create,query,edit]
            Changes the range of values that the profile curve represents. eg. if the
            profile curve values go between 0 and 1 and this value is set to 2 then the
            profile curves values will be adjusted to go between 0 and 2. Default:1.0f
        
        - profileCurve_FloatValue : pfv  (float)         [create,query,edit]
            ?????
        
        - profileCurve_Interp : pi       (int)           [create,query,edit]
            ????? Default:0
        
        - profileCurve_Position : pp     (float)         [create,query,edit]
            ?????
        
        - rootEdge : re                  (int)           [create,query,edit]
            The weight attribute uses the start vertex of this edge to determine where the
            new split occurs. Default:-1
        
        - smoothingAngle : sma           (float)         [create,query,edit]
            Angle below which new edges will be smoothed Default:kPi
        
        - splitType : stp                (int)           [create,query,edit]
            Format: 0 - Absolute, 1 - Relative, 2 - Multi Default:TdnpolySplitRing::Relative
        
        - useEqualMultiplier : uem       (bool)          [create,query,edit]
            Changes how the profile curve effects the offset when doing a multisplit.  If
            true then the verts will be offset the same distance based on the shortest edge
            being split.  If false then each inserted edge loop will be offset a distance
            relative to the length of the edge that is being split. Default:true
        
        - useFaceNormalsAtEnds : fne     (bool)          [create,query,edit]
            When doing a multisplit on a set of non-closed edge ring this will toggle the
            normals at the ends of the split to be calculated as the edge normal or the face
            normal. Default:true
        
        - weight : wt                    (float)         [create,query,edit]
            Weight value controlling the relative positioning of the new points on existing
            edges. Range is [0.0, 1.0]. Value of 0.1 indicates the new edges will be placed
            closer to the start vertex of the first edge of the sequence of edges.
            Default:0.5
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polySplitRing`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveWarp(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PhongE(Reflect):
    def getHighlightSize(self):
        """
        Retrieves the value of the "highlightSize" attribute of a shader node. This attribute represents the surface color of the shader.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnPhongEShader.highlightSize`
        """
        pass
    def getRoughness(self):
        """
        Retrieves the value of the "roughness" attribute of a shader node.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnPhongEShader.roughness`
        """
        pass
    def getWhiteness(self):
        """
        Retrieves the value of the "whiteness" attribute of a shader node. This attribute represents the surface transparency of the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnPhongEShader.whiteness`
        """
        pass
    def setHighlightSize(self, highlight_size):
        """
        Sets the value of the "highlightSize" attribute of a shader node.
        
        Parameters:
        highlight_size : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnPhongEShader.setHighlightSize`
        """
        pass
    def setRoughness(self, roughness):
        """
        Sets the value of the "roughness" attribute of a shader node.
        
        Parameters:
        roughness : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnPhongEShader.setRoughness`
        """
        pass
    def setWhiteness(self, whiteness):
        """
        Sets the value of the "whiteness" attribute of a shader node.
        
        Parameters:
        whiteness : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnPhongEShader.setWhiteness`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class JointCluster(Cluster):
    def getAboveBound(self, **kwargs):
        """
        Specifies the where the drop-off begins in the direction of the bone above the joint. A value of 100 indicates the entire length of the bone. The default value is 10.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getAboveCluster(self, **kwargs):
        """
        Returns the name of the cluster associated with the bone above this joint.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getAboveDropoffType(self, **kwargs):
        """
        Specifies the type of percentage drop-off in the direction of the bone above this joint. Valid values are linear, exponential, sineand none. Default is linear.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getAboveValue(self, **kwargs):
        """
        Specifies the drop-off percentage of the joint cluster in the direction of the bone above the cluster. A value of 100 indicates the entire length of the bone. The default value is 50.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getBelowBound(self, **kwargs):
        """
        Specifies where the drop-off ends in the direction of the bone below the joint. A value of 100 indicates the entire length of the bone. The default value is 10.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getBelowCluster(self, **kwargs):
        """
        Returns the name of the cluster associated with this joint.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getBelowDropoffType(self, **kwargs):
        """
        Specifies the type of type of percentage drop-off in the direction of the bone below this joint. Valid values are linear, exponential, sineand none. Default is linear.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getBelowValue(self, **kwargs):
        """
        Specifies the drop-off percentage of the joint cluster in the direction of the joint below the cluster. A value of 100 indicates the entire length of the bone. The default value is 50.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Used to query for the helper nodes associated with the jointCluster.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def setAboveBound(self, val='True', **kwargs):
        """
        Specifies the where the drop-off begins in the direction of the bone above the joint. A value of 100 indicates the entire length of the bone. The default value is 10.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def setAboveDropoffType(self, val='True', **kwargs):
        """
        Specifies the type of percentage drop-off in the direction of the bone above this joint. Valid values are linear, exponential, sineand none. Default is linear.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def setAboveValue(self, val='True', **kwargs):
        """
        Specifies the drop-off percentage of the joint cluster in the direction of the bone above the cluster. A value of 100 indicates the entire length of the bone. The default value is 50.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def setBelowBound(self, val='True', **kwargs):
        """
        Specifies where the drop-off ends in the direction of the bone below the joint. A value of 100 indicates the entire length of the bone. The default value is 10.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def setBelowDropoffType(self, val='True', **kwargs):
        """
        Specifies the type of type of percentage drop-off in the direction of the bone below this joint. Valid values are linear, exponential, sineand none. Default is linear.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    def setBelowValue(self, val='True', **kwargs):
        """
        Specifies the drop-off percentage of the joint cluster in the direction of the joint below the cluster. A value of 100 indicates the entire length of the bone. The default value is 50.                  
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The joint cluster command adds high-level controls to manage the cluster
        percentage values on a bound skin around a joint. JointClusters are one way to
        create smooth bending behaviour on skin when joints rotate. .                a
        ---- aboveBound .    ____________a_________ .                a         \ .
        Joint1     a       Joint2 .   _____________a_______    \ .                a
        \    \     b  --- belowBound .                a        \    \  b .
        \    b .                           \ b  \ .                           b\    \ .
        b   \ Joint3 CVs/vertices between Joint1 and aaaaa (aboveBound) receive only
        translation/rotation/scale from Joint1. CVs vertices between aaaa and bbbb
        transition between translation/rotatation/scale from Joint1 and Joint2. CV2
        beyand bbbbb (below bound) receive only translation/ rotation scale from Joint3.
        
        Flags:
        - aboveBound : ab                (float)         [create,query,edit]
            Specifies the where the drop-off begins in the direction of the bone above the
            joint. A value of 100 indicates the entire length of the bone. The default value
            is 10.
        
        - aboveCluster : ac              (bool)          [query]
            Returns the name of the cluster associated with the bone above this joint.
        
        - aboveDropoffType : adt         (unicode)       [create,query,edit]
            Specifies the type of percentage drop-off in the direction of the bone above
            this joint. Valid values are linear, exponential, sineand none. Default is
            linear.
        
        - aboveValue : av                (float)         [create,query,edit]
            Specifies the drop-off percentage of the joint cluster in the direction of the
            bone above the cluster. A value of 100 indicates the entire length of the bone.
            The default value is 50.
        
        - belowBound : bb                (float)         [create,query,edit]
            Specifies where the drop-off ends in the direction of the bone below the joint.
            A value of 100 indicates the entire length of the bone. The default value is 10.
        
        - belowCluster : bc              (bool)          [query]
            Returns the name of the cluster associated with this joint.
        
        - belowDropoffType : bdt         (unicode)       [create,query,edit]
            Specifies the type of type of percentage drop-off in the direction of the bone
            below this joint. Valid values are linear, exponential, sineand none. Default is
            linear.
        
        - belowValue : bv                (float)         [create,query,edit]
            Specifies the drop-off percentage of the joint cluster in the direction of the
            joint below the cluster. A value of 100 indicates the entire length of the bone.
            The default value is 50.
        
        - deformerTools : dt             (bool)          [query]
            Used to query for the helper nodes associated with the jointCluster.
        
        - joint : j                      (unicode)       [create]
            Specifies the joint that the cluster should act about.
        
        - name : n                       (unicode)       [create]
            This flag is obsolete.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.jointCluster`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CreaseSet(ObjectSet):
    __melnode__ = []
    
    
    __readonly__ = {}


class Anisotropic(Reflect):
    def getAnisotropicReflectivity(self):
        """
        Retrieves the value of the "anisotropicReflectivity" attribute of a layered shader node.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.anisotropicReflectivity`
        """
        pass
    def getCorrelationX(self):
        """
        Retrieves the value of the "spreadX" attribute of a shader node.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.correlationX`
        """
        pass
    def getCorrelationY(self):
        """
        Retrieves the value of the "spreadY" attribute of a shader node.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.correlationY`
        """
        pass
    def getFresnelRefractiveIndex(self):
        """
        Retrieves the value of the "fresnelRefractiveIndex" attribute of a layered shader node.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.refractiveIndex`
        """
        pass
    def getRotateAngle(self):
        """
        Retrieves the value of the "angle" attribute of a layered shader node.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.rotateAngle`
        """
        pass
    def getRoughness(self):
        """
        Retrieves the value of the "roughness" attribute of a shader node.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.roughness`
        """
        pass
    def getTangentUCamera(self):
        """
        Retrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.tangentUCamera`
        """
        pass
    def getTangentVCamera(self):
        """
        Retrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.tangentVCamera`
        """
        pass
    def setAnisotropicReflectivity(self, anisotropic_reflectivity):
        """
        Sets the value of the "anisotropicReflectivity" attribute of a shader node.
        
        Parameters:
        anisotropic_reflectivity : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setAnisotropicReflectivity`
        """
        pass
    def setCorrelationX(self, correl_x):
        """
        Sets the value of the "spreadX" attribute of a shader node.
        
        Parameters:
        correl_x : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setCorrelationX`
        """
        pass
    def setCorrelationY(self, correl_y):
        """
        Sets the value of the "spreadY" attribute of a shader node.
        
        Parameters:
        correl_y : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setCorrelationY`
        """
        pass
    def setFresnelRefractiveIndex(self, refractive_index):
        """
        Sets the value of the "fresnelRefractiveIndex" attribute of a shader node.
        
        Parameters:
        refractive_index : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setRefractiveIndex`
        """
        pass
    def setRotateAngle(self, rotate_angle):
        """
        Sets the value of the "angle" attribute of a shader node.
        
        Parameters:
        rotate_angle : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setRotateAngle`
        """
        pass
    def setRoughness(self, roughness):
        """
        Sets the value of the "roughness" attribute of a shader node.
        
        Parameters:
        roughness : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setRoughness`
        """
        pass
    def setTangentUCamera(self, tangu_camera):
        """
        Sets the value of the "color" attribute of a shader node.
        
        Parameters:
        tangu_camera : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setTangentUCamera`
        """
        pass
    def setTangentVCamera(self, tangv_camera):
        """
        Sets the value of the "transparency" attribute of a shader node.
        
        Parameters:
        tangv_camera : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAnisotropyShader.setTangentVCamera`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HIKCharacterStateClient(THclientDevice):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ShadingEngine(ObjectSet):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyModifierUV(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMirror(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class ShaderfxGameHair(THhardwareShader):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ShaderfxShader(THhardwareShader):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPlanarProj(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbs3FloatsOverride(ApplyAbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AnimLayer(ObjectSet):
    def copy(self, val='True', **kwargs):
        """
        Copy from layer.                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def copyAnimation(self, val='True', **kwargs):
        """
        Copy animation from specified layer to destination layer, only animation that are on attribute layered by both layer that are concerned.                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def copyNoAnimation(self, val='True', **kwargs):
        """
        Copy from layer without the animation curves.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def extractAnimation(self, val='True', **kwargs):
        """
        Transfer animation from specified layer to destination layer, only animation that are on attribute layered by both layer that are concerned.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getAddRelatedKG(self, **kwargs):
        """
        Used adding attributes to a layer. Determines if associated keying groups should be added or not to the layer.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getAddSelectedObjects(self, **kwargs):
        """
        Adds selected object(s) to the layer.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getAffectedLayers(self, **kwargs):
        """
        Return the layers that the currently selected object(s) are members of                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getAnimCurves(self, **kwargs):
        """
        In query mode returns the anim curves associated with this layer                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getAttribute(self):
        """
        Retrieve the attributes animated on this AnimLayer
        """
        pass
    def getAttributes(self):
        """
        Retrieve the attributes animated on this AnimLayer
        """
        pass
    def getBaseAnimCurves(self, **kwargs):
        """
        In query mode returns the base layer anim curves associated with this layer, if any.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getBestAnimLayer(self, **kwargs):
        """
        In query mode returns the best anim layers for keying for the selected objects. If used in conjunction with -at, will return the best anim layers for keying for the specific plugs (attributes) specified.                                
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getBestLayer(self, **kwargs):
        """
        Return the layer that will be keyed for specified attribute.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getBlendNodes(self, **kwargs):
        """
        In query mode returns the blend nodes associated with this layer                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getChildren(self, **kwargs):
        """
        Get the list of children layers. Return value is a string array.                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getCollapse(self, **kwargs):
        """
        Determine if a layer is collapse in the layer editor.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExcludeBoolean(self, **kwargs):
        """
        When adding selected object(s) to the layer, excludes any boolean attributes.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExcludeDynamic(self, **kwargs):
        """
        When adding selected object(s) to the layer, excludes any dynamic attributes.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExcludeEnum(self, **kwargs):
        """
        When adding selected object(s) to the layer, excludes any enum attributes.                                 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExcludeRotate(self, **kwargs):
        """
        When adding selected object(s) to the layer, exclude the rotate attribute.                                 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExcludeScale(self, **kwargs):
        """
        When adding selected object(s) to the layer, exclude the scale attribute.                                  
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExcludeTranslate(self, **kwargs):
        """
        When adding selected object(s) to the layer, excludes the translate attribute.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExcludeVisibility(self, **kwargs):
        """
        When adding selected object(s) to the layer, exclude the visibility attribute.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getExists(self, **kwargs):
        """
        Determine if an layer exists.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getFindCurveForPlug(self, **kwargs):
        """
        Finds the parameter curve containing the animation data for the specified plug on the given layer. 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getLayeredPlug(self, **kwargs):
        """
        Returns the plug on the blend node corresponding to the specified layer 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getLock(self, **kwargs):
        """
        Set the lock state of the specified layer. A locked layer cannot receive key. Default is false.                                    
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getMaxLayers(self, **kwargs):
        """
        Returns the maximum number of anim layers supported by this product.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getMute(self, **kwargs):
        """
        Set the mute state of the specified layer. Default is false.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getOverride(self, **kwargs):
        """
        Set the overide state of the specified layer. Default is false.                                    
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getParent(self, **kwargs):
        """
        Set the parent of the specified layer. Default is the animation layer root.                                
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getPassthrough(self, **kwargs):
        """
        Set the passthrough state of the specified layer. Default is true.                                 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getPreferred(self, **kwargs):
        """
        Determine if a layer is a preferred layer, the best layer algorithm will try to set keyframe in preferred layer first.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getRoot(self, **kwargs):
        """
        Return the base layer if it exist                                  
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getSelected(self, **kwargs):
        """
        Determine if a layer is selected, a selected layer will be show in the timecontrol, graph editor.                                  
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getSolo(self, **kwargs):
        """
        Set the solo state of the specified layer. Default is false.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def getWeight(self, **kwargs):
        """
        Set the weight of the specified layer between 0.0 and 1.0. Default is 1.                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def moveLayerAfter(self, val='True', **kwargs):
        """
        Move layer after the specified layer                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def moveLayerBefore(self, val='True', **kwargs):
        """
        Move layer before the specified layer                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def removeAllAttributes(self, val='True', **kwargs):
        """
        Remove all objects from layer.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setAddRelatedKG(self, val='True', **kwargs):
        """
        Used adding attributes to a layer. Determines if associated keying groups should be added or not to the layer.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setAddSelectedObjects(self, val='True', **kwargs):
        """
        Adds selected object(s) to the layer.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setAnimCurves(self, val='True', **kwargs):
        """
        In query mode returns the anim curves associated with this layer                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        Adds a specific attribute on a object to the layer.                                
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setBaseAnimCurves(self, val='True', **kwargs):
        """
        In query mode returns the base layer anim curves associated with this layer, if any.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setBestAnimLayer(self, val='True', **kwargs):
        """
        In query mode returns the best anim layers for keying for the selected objects. If used in conjunction with -at, will return the best anim layers for keying for the specific plugs (attributes) specified.                                
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setBlendNodes(self, val='True', **kwargs):
        """
        In query mode returns the blend nodes associated with this layer                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setCollapse(self, val='True', **kwargs):
        """
        Determine if a layer is collapse in the layer editor.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setExcludeBoolean(self, val='True', **kwargs):
        """
        When adding selected object(s) to the layer, excludes any boolean attributes.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setExcludeDynamic(self, val='True', **kwargs):
        """
        When adding selected object(s) to the layer, excludes any dynamic attributes.                              
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setExcludeEnum(self, val='True', **kwargs):
        """
        When adding selected object(s) to the layer, excludes any enum attributes.                                 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setExcludeRotate(self, val='True', **kwargs):
        """
        When adding selected object(s) to the layer, exclude the rotate attribute.                                 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setExcludeScale(self, val='True', **kwargs):
        """
        When adding selected object(s) to the layer, exclude the scale attribute.                                  
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setExcludeTranslate(self, val='True', **kwargs):
        """
        When adding selected object(s) to the layer, excludes the translate attribute.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setExcludeVisibility(self, val='True', **kwargs):
        """
        When adding selected object(s) to the layer, exclude the visibility attribute.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setFindCurveForPlug(self, val='True', **kwargs):
        """
        Finds the parameter curve containing the animation data for the specified plug on the given layer. 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setLock(self, val='True', **kwargs):
        """
        Set the lock state of the specified layer. A locked layer cannot receive key. Default is false.                                    
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setMute(self, val='True', **kwargs):
        """
        Set the mute state of the specified layer. Default is false.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setOverride(self, val='True', **kwargs):
        """
        Set the overide state of the specified layer. Default is false.                                    
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Set the parent of the specified layer. Default is the animation layer root.                                
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setPassthrough(self, val='True', **kwargs):
        """
        Set the passthrough state of the specified layer. Default is true.                                 
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setPreferred(self, val='True', **kwargs):
        """
        Determine if a layer is a preferred layer, the best layer algorithm will try to set keyframe in preferred layer first.                             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setSelected(self, val='True', **kwargs):
        """
        Determine if a layer is selected, a selected layer will be show in the timecontrol, graph editor.                                  
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setSolo(self, val='True', **kwargs):
        """
        Set the solo state of the specified layer. Default is false.                               
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def setWeight(self, val='True', **kwargs):
        """
        Set the weight of the specified layer between 0.0 and 1.0. Default is 1.                                   
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    def writeBlendnodeDestinations(self, val='True', **kwargs):
        """
        In edit mode writes the destination plugs of the blend nodes that belong to the layer into the blend node. This is used for layer import/export purposes and is not for general use.                               Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates and edits animation layers.
        
        Flags:
        - addRelatedKG : akg             (bool)          [create,query,edit]
            Used adding attributes to a layer. Determines if associated keying groups should
            be added or not to the layer.
        
        - addSelectedObjects : aso       (bool)          [create,query,edit]
            Adds selected object(s) to the layer.
        
        - affectedLayers : afl           (bool)          [query]
            Return the layers that the currently selected object(s) are members of
        
        - animCurves : anc               (bool)          [create,query,edit]
            In query mode returns the anim curves associated with this layer
        
        - attribute : at                 (unicode)       [create,query,edit]
            Adds a specific attribute on a object to the layer.
        
        - baseAnimCurves : bac           (bool)          [create,query,edit]
            In query mode returns the base layer anim curves associated with this layer, if
            any.
        
        - bestAnimLayer : blr            (bool)          [create,query,edit]
            In query mode returns the best anim layers for keying for the selected objects.
            If used in conjunction with -at, will return the best anim layers for keying for
            the specific plugs (attributes) specified.
        
        - bestLayer : bl                 (bool)          [query]
            Return the layer that will be keyed for specified attribute.
        
        - blendNodes : bld               (bool)          [create,query,edit]
            In query mode returns the blend nodes associated with this layer
        
        - children : c                   (unicode)       [query]
            Get the list of children layers. Return value is a string array.
        
        - collapse : col                 (bool)          [create,query,edit]
            Determine if a layer is collapse in the layer editor.
        
        - copy : cp                      (unicode)       [edit]
            Copy from layer.
        
        - copyAnimation : ca             (unicode)       [create,edit]
            Copy animation from specified layer to destination layer, only animation that
            are on attribute layered by both layer that are concerned.
        
        - copyNoAnimation : cna          (unicode)       [edit]
            Copy from layer without the animation curves.
        
        - excludeBoolean : ebl           (bool)          [create,query,edit]
            When adding selected object(s) to the layer, excludes any boolean attributes.
        
        - excludeDynamic : edn           (bool)          [create,query,edit]
            When adding selected object(s) to the layer, excludes any dynamic attributes.
        
        - excludeEnum : een              (bool)          [create,query,edit]
            When adding selected object(s) to the layer, excludes any enum attributes.
        
        - excludeRotate : ert            (bool)          [create,query,edit]
            When adding selected object(s) to the layer, exclude the rotate attribute.
        
        - excludeScale : esc             (bool)          [create,query,edit]
            When adding selected object(s) to the layer, exclude the scale attribute.
        
        - excludeTranslate : etr         (bool)          [create,query,edit]
            When adding selected object(s) to the layer, excludes the translate attribute.
        
        - excludeVisibility : evs        (bool)          [create,query,edit]
            When adding selected object(s) to the layer, exclude the visibility attribute.
        
        - exists : ex                    (bool)          [query]
            Determine if an layer exists.
        
        - extractAnimation : ea          (unicode)       [create,edit]
            Transfer animation from specified layer to destination layer, only animation
            that are on attribute layered by both layer that are concerned.
        
        - findCurveForPlug : fcv         (unicode)       [query,edit]
            Finds the parameter curve containing the animation data for the specified plug
            on the given layer.
        
        - forceUIRebuild : fur           (bool)          [create]
            Rebuilds the animation layers user interface.
        
        - forceUIRefresh : uir           (bool)          [create]
            Refreshes the animation layers user interface.
        
        - layeredPlug : lp               (unicode)       [query]
            Returns the plug on the blend node corresponding to the specified layer
        
        - lock : l                       (bool)          [create,query,edit]
            Set the lock state of the specified layer. A locked layer cannot receive key.
            Default is false.
        
        - maxLayers : ml                 (bool)          [query]
            Returns the maximum number of anim layers supported by this product.
        
        - moveLayerAfter : mva           (unicode)       [edit]
            Move layer after the specified layer
        
        - moveLayerBefore : mvb          (unicode)       [edit]
            Move layer before the specified layer
        
        - mute : m                       (bool)          [create,query,edit]
            Set the mute state of the specified layer. Default is false.
        
        - override : o                   (bool)          [create,query,edit]
            Set the overide state of the specified layer. Default is false.
        
        - parent : p                     (unicode)       [create,query,edit]
            Set the parent of the specified layer. Default is the animation layer root.
        
        - passthrough : pth              (bool)          [create,query,edit]
            Set the passthrough state of the specified layer. Default is true.
        
        - preferred : prf                (bool)          [create,query,edit]
            Determine if a layer is a preferred layer, the best layer algorithm will try to
            set keyframe in preferred layer first.
        
        - removeAllAttributes : raa      (bool)          [edit]
            Remove all objects from layer.
        
        - removeAttribute : ra           (unicode)       [edit]
            Remove object from layer.
        
        - root : r                       (unicode)       [query]
            Return the base layer if it exist
        
        - selected : sel                 (bool)          [create,query,edit]
            Determine if a layer is selected, a selected layer will be show in the
            timecontrol, graph editor.
        
        - solo : s                       (bool)          [create,query,edit]
            Set the solo state of the specified layer. Default is false.
        
        - weight : w                     (float)         [create,query,edit]
            Set the weight of the specified layer between 0.0 and 1.0. Default is 1.
        
        - writeBlendnodeDestinations : wbd (bool)          [edit]
            In edit mode writes the destination plugs of the blend nodes that belong to the
            layer into the blend node. This is used for layer import/export purposes and is
            not for general use.                               Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.animLayer`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCone(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the cone. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the cone. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getRadius(self, **kwargs):
        """
        Radius of the cone. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getRoundCap(self, **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getSubdivisionsAxis(self, **kwargs):
        """
        Subdivisions around the axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getSubdivisionsCap(self, **kwargs):
        """
        Subdivisions on the bottom cap. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getSubdivisionsX(self, **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the cone. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getSubdivisionsY(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the cone. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getSubdivisionsZ(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Z direction for the cone. C: Default is 0. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def getTexture(self, **kwargs):
        """
        Apply texture or not. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the cone. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the cone. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        Radius of the cone. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setRoundCap(self, val='True', **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setSubdivisionsAxis(self, val='True', **kwargs):
        """
        Subdivisions around the axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setSubdivisionsCap(self, val='True', **kwargs):
        """
        Subdivisions on the bottom cap. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setSubdivisionsX(self, val='True', **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the cone. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setSubdivisionsY(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the cone. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setSubdivisionsZ(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Z direction for the cone. C: Default is 0. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        Apply texture or not. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The cone command creates a new polygonal cone.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the cone. Q: When queried,
            this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create,query,edit]
            Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and
            Preserve Aspect RatioDefault:2
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - height : h                     (float)         [create,query,edit]
            Height of the cone. Default:2.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - radius : r                     (float)         [create,query,edit]
            Radius of the cone. Default:1.0
        
        - roundCap : rcp                 (bool)          [create,query,edit]
            To indicate whether we need a round cap Default:false
        
        - subdivisionsAxis : sa          (int)           [create,query,edit]
            Subdivisions around the axis. Default:20
        
        - subdivisionsCap : sc           (int)           [create,query,edit]
            Subdivisions on the bottom cap. Default:0
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height. Default:1
        
        - subdivisionsX : sx             (int)           [create,query,edit]
            This specifies the number of subdivisions in the X direction for the cone. C:
            Default is 20. Q: When queried, this flag returns an int.
        
        - subdivisionsY : sy             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Y direction for the cone.
            C: Default is 1. Q: When queried, this flag returns an int.
        
        - subdivisionsZ : sz             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Z direction for the cone.
            C: Default is 0. Q: When queried, this flag returns an int.
        
        - texture : tx                   (bool)          [create,query,edit]
            Apply texture or not. Default:true                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCone`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class UnknownDag(DagNode):
    __melnode__ = []
    
    
    __readonly__ = {}


class BasicSelector(SimpleSelector):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySubdEdge(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdModifierUV(SubdModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Deformer(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class StingrayPBS(THhardwareShader):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMoveVertex(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getGain(self, **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalDirection(self, **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalDirectionX(self, **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalDirectionY(self, **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalDirectionZ(self, **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalTranslate(self, **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalTranslateX(self, **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalTranslateY(self, **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getLocalTranslateZ(self, **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getPivotX(self, **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getPivotY(self, **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getPivotZ(self, **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getRandom(self, **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getRotate(self, **kwargs):
        """
        Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getRotateX(self, **kwargs):
        """
        Rotation angle around X.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getRotateY(self, **kwargs):
        """
        Rotation angle around Y.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getRotateZ(self, **kwargs):
        """
        Rotation angle around Z.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getScale(self, **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getScaleX(self, **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getScaleY(self, **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getScaleZ(self, **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getTranslate(self, **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getTranslateX(self, **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getTranslateY(self, **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getTranslateZ(self, **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setGain(self, val='True', **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalDirection(self, val='True', **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalDirectionX(self, val='True', **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalDirectionY(self, val='True', **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalDirectionZ(self, val='True', **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalTranslate(self, val='True', **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalTranslateX(self, val='True', **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalTranslateY(self, val='True', **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setLocalTranslateZ(self, val='True', **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setPivotX(self, val='True', **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setPivotY(self, val='True', **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setPivotZ(self, val='True', **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setRandom(self, val='True', **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setRotate(self, val='True', **kwargs):
        """
        Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setRotateX(self, val='True', **kwargs):
        """
        Rotation angle around X.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setRotateY(self, val='True', **kwargs):
        """
        Rotation angle around Y.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setRotateZ(self, val='True', **kwargs):
        """
        Rotation angle around Z.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setScaleX(self, val='True', **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setScaleY(self, val='True', **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setScaleZ(self, val='True', **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setTranslate(self, val='True', **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setTranslateX(self, val='True', **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setTranslateY(self, val='True', **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setTranslateZ(self, val='True', **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Modifies vertices of a polygonal object. Translate, rotate or scale vertices in
        local or world space.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - gain : ga                      (float)         [create,query,edit]
            Gain factor per component. Can be painted using Artisan. Default:1.0
        
        - localDirection : ld            (float, float, float) [create,query,edit]
            Direction to determine X axis for local space. Default:1.0, 0.0, 0.0
        
        - localDirectionX : ldx          (float)         [create,query,edit]
            X coord of the X axis.
        
        - localDirectionY : ldy          (float)         [create,query,edit]
            Y coord of the X axis.
        
        - localDirectionZ : ldz          (float)         [create,query,edit]
            Z coord of the X axis.
        
        - localTranslate : lt            (float, float, float) [create,query,edit]
            Local translate. Default:0.0, 0.0, 0.0
        
        - localTranslateX : ltx          (float)         [create,query,edit]
            Local translation X coord.
        
        - localTranslateY : lty          (float)         [create,query,edit]
            Local translation Y coord.
        
        - localTranslateZ : ltz          (float)         [create,query,edit]
            Local translation Z coord : Move along the normal.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - pivot : pvt                    (float, float, float) [create,query,edit]
            The pivot for scaling and rotation. Default:0.0, 0.0, 0.0
        
        - pivotX : pvx                   (float)         [create,query,edit]
            Pivot X coord.
        
        - pivotY : pvy                   (float)         [create,query,edit]
            Pivot Y coord.
        
        - pivotZ : pvz                   (float)         [create,query,edit]
            Pivot Z coord.
        
        - random : ran                   (float)         [create,query,edit]
            Random value for all parameters. Default:0.0
        
        - rotate : ro                    (float, float, float) [create,query,edit]
            Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0
        
        - rotateX : rx                   (float)         [create,query,edit]
            Rotation angle around X.
        
        - rotateY : ry                   (float)         [create,query,edit]
            Rotation angle around Y.
        
        - rotateZ : rz                   (float)         [create,query,edit]
            Rotation angle around Z.
        
        - scale : s                      (float, float, float) [create,query,edit]
            Scaling vector. Default:1.0, 1.0, 1.0
        
        - scaleX : sx                    (float)         [create,query,edit]
            Scale X coord.
        
        - scaleY : sy                    (float)         [create,query,edit]
            Scale Y coord.
        
        - scaleZ : sz                    (float)         [create,query,edit]
            Scale Z coord.
        
        - translate : t                  (float, float, float) [create,query,edit]
            Translation vector. Default:0.0, 0.0, 0.0
        
        - translateX : tx                (float)         [create,query,edit]
            Translation X coord.
        
        - translateY : ty                (float)         [create,query,edit]
            Translation Y coord.
        
        - translateZ : tz                (float)         [create,query,edit]
            Translation Z coord.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMoveVertex`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THobjectSet(ObjectSet):
    __melnode__ = []
    
    
    __readonly__ = {}


class LightsCollectionSelector(SimpleSelector):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPassThru(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class HairTubeShader(Reflect):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyQuad(PolyModifierWorld):
    def getAngle(self, **kwargs):
        """
        Angle threshold above which two triangles are not merged. C: Default is 30 degrees. The range is [0.0, 180.0]. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def getKeepGroupBorder(self, **kwargs):
        """
        Keep facet group border : If on, the borders of selected faces are maintained, otherwise the borders of selected facets may be modified. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def getKeepHardEdges(self, **kwargs):
        """
        Keep hard edges : If on, the hard edges of selected faces are maintained, otherwise they may be deleted between two triangles. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def getKeepTextureBorders(self, **kwargs):
        """
        Keep texture border : If on, the borders of texture maps are maintained, otherwise the boreders of texture maps may be modified. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def setAngle(self, val='True', **kwargs):
        """
        Angle threshold above which two triangles are not merged. C: Default is 30 degrees. The range is [0.0, 180.0]. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def setKeepGroupBorder(self, val='True', **kwargs):
        """
        Keep facet group border : If on, the borders of selected faces are maintained, otherwise the borders of selected facets may be modified. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def setKeepHardEdges(self, val='True', **kwargs):
        """
        Keep hard edges : If on, the hard edges of selected faces are maintained, otherwise they may be deleted between two triangles. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def setKeepTextureBorders(self, val='True', **kwargs):
        """
        Keep texture border : If on, the borders of texture maps are maintained, otherwise the boreders of texture maps may be modified. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Merges selected triangles of a polygonal object into four-sided faces.
        
        Flags:
        - angle : a                      (float)         [create,query,edit]
            Angle threshold above which two triangles are not merged. C: Default is 30
            degrees. The range is [0.0, 180.0]. Q: When queried, this flag returns a float.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - keepGroupBorder : kgb          (bool)          [create,query,edit]
            Keep facet group border : If on, the borders of selected faces are maintained,
            otherwise the borders of selected facets may be modified. C: Default is on. Q:
            When queried, this flag returns an int.
        
        - keepHardEdges : khe            (bool)          [create,query,edit]
            Keep hard edges : If on, the hard edges of selected faces are maintained,
            otherwise they may be deleted between two triangles. C: Default is on. Q: When
            queried, this flag returns an int.
        
        - keepTextureBorders : ktb       (bool)          [create,query,edit]
            Keep texture border : If on, the borders of texture maps are maintained,
            otherwise the boreders of texture maps may be modified. C: Default is on. Q:
            When queried, this flag returns an int.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyQuad`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCube(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the cube. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize Each Face Separately3: Normalize Collectively4: Normalize and Preserve Aspect RatioDefault:3                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getDepth(self, **kwargs):
        """
        Depth of the cube. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the cube. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getSubdivisionsDepth(self, **kwargs):
        """
        Subdivisions along the depth of the cube. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height of the cube. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getSubdivisionsWidth(self, **kwargs):
        """
        Subdivisions along the width of the cube. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getSubdivisionsX(self, **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the cube. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getSubdivisionsY(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the cube. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getSubdivisionsZ(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Z direction for the cube. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getTexture(self, **kwargs):
        """
        What texture mechanism to be applied 0=No textures; 1=Object; 2=Faces Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def getWidth(self, **kwargs):
        """
        Width of the cube. Default:1.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the cube. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize Each Face Separately3: Normalize Collectively4: Normalize and Preserve Aspect RatioDefault:3                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setDepth(self, val='True', **kwargs):
        """
        Depth of the cube. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the cube. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setSubdivisionsDepth(self, val='True', **kwargs):
        """
        Subdivisions along the depth of the cube. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height of the cube. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setSubdivisionsWidth(self, val='True', **kwargs):
        """
        Subdivisions along the width of the cube. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setSubdivisionsX(self, val='True', **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the cube. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setSubdivisionsY(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the cube. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setSubdivisionsZ(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Z direction for the cube. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        What texture mechanism to be applied 0=No textures; 1=Object; 2=Faces Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        Width of the cube. Default:1.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The cube command creates a new polygonal cube.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the cube. Q: When queried,
            this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create,query,edit]
            Create UVs or not. 0: No UVs1: No Normalization2: Normalize Each Face
            Separately3: Normalize Collectively4: Normalize and Preserve Aspect
            RatioDefault:3
        
        - depth : d                      (float)         [create,query,edit]
            Depth of the cube. Default:1.0
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - height : h                     (float)         [create,query,edit]
            Height of the cube. Default:1.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - subdivisionsDepth : sd         (int)           [create,query,edit]
            Subdivisions along the depth of the cube. Default:1
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height of the cube. Default:1
        
        - subdivisionsWidth : sw         (int)           [create,query,edit]
            Subdivisions along the width of the cube. Default:1
        
        - subdivisionsX : sx             (int)           [create,query,edit]
            This specifies the number of subdivisions in the X direction for the cube. C:
            Default is 1. Q: When queried, this flag returns an int.
        
        - subdivisionsY : sy             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Y direction for the cube.
            C: Default is 1. Q: When queried, this flag returns an int.
        
        - subdivisionsZ : sz             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Z direction for the cube.
            C: Default is 1. Q: When queried, this flag returns an int.
        
        - texture : tx                   (int)           [create,query,edit]
            What texture mechanism to be applied 0=No textures; 1=Object; 2=Faces Default:1
        
        - width : w                      (float)         [create,query,edit]
            Width of the cube. Default:1.0                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCube`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySewEdge(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def getTexture(self, **kwargs):
        """
        If true : texture is sewn as well as the 3d edge. C: Default is true. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance to sew edges (edge distance) C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        If true : texture is sewn as well as the 3d edge. C: Default is true. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance to sew edges (edge distance) C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Merge border edges within a given threshold.Perform pair-wise comparison of
        selected edges. Pairs whose corresponding vertices meet threshold conditions and
        whose orientations are aligned (i.e. their respective normals point in the same
        direction) are merged, as are the vertices (in other words, vertices are
        shared). Resulting mesh may have extra vertices or edges to ensure geometry is
        valid. Edges must be on the same object to be merged. Default : share only
        vertices lying exactly at the same place. (polySewEdge -t 0.0)
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - texture : tx                   (bool)          [create,query,edit]
            If true : texture is sewn as well as the 3d edge. C: Default is true. Q: When
            queried, this flag returns an int.
        
        - tolerance : t                  (float)         [create,query,edit]
            The tolerance to sew edges (edge distance) C: Default is 0.0. Q: When queried,
            this flag returns a float.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polySewEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ShellTessellate(ParentTessellate):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyHelix(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getCoils(self, **kwargs):
        """
        Number of coils. Default:3                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getDirection(self, **kwargs):
        """
        What should be the direction of the coil. 0=Clockwise; 1=Counterclockwise Default:1                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the helix. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getRadius(self, **kwargs):
        """
        Radius of tube. Default:0.4                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getRoundCap(self, **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getSubdivisionsAxis(self, **kwargs):
        """
        Subdivisions around the axis. Default:8                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getSubdivisionsCaps(self, **kwargs):
        """
        Subdivisions along the thickness caps. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getSubdivisionsCoil(self, **kwargs):
        """
        Subdivisions along the coil. Default:50                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getTexture(self, **kwargs):
        """
        What texture mechanism to be applied 0=No textures; 1=Object; 2=Faces Default:2                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getUseOldInitBehaviour(self, **kwargs):
        """
        Create the helix with base on the origin as in Maya V8.0 and below Otherwise create helix centred at origin Default:false                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def getWidth(self, **kwargs):
        """
        Width of the helix. Default:2.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setCoils(self, val='True', **kwargs):
        """
        Number of coils. Default:3                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setDirection(self, val='True', **kwargs):
        """
        What should be the direction of the coil. 0=Clockwise; 1=Counterclockwise Default:1                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the helix. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        Radius of tube. Default:0.4                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setRoundCap(self, val='True', **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setSubdivisionsAxis(self, val='True', **kwargs):
        """
        Subdivisions around the axis. Default:8                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setSubdivisionsCaps(self, val='True', **kwargs):
        """
        Subdivisions along the thickness caps. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setSubdivisionsCoil(self, val='True', **kwargs):
        """
        Subdivisions along the coil. Default:50                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        What texture mechanism to be applied 0=No textures; 1=Object; 2=Faces Default:2                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setUseOldInitBehaviour(self, val='True', **kwargs):
        """
        Create the helix with base on the origin as in Maya V8.0 and below Otherwise create helix centred at origin Default:false                  
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        Width of the helix. Default:2.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The polyHelix command creates a new polygonal helix.
        
        Flags:
        - axis : ax                      (float, float, float) [query,edit]
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - coils : c                      (float)         [create,query,edit]
            Number of coils. Default:3
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create,query,edit]
            Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and
            Preserve Aspect RatioDefault:2
        
        - direction : d                  (int)           [create,query,edit]
            What should be the direction of the coil. 0=Clockwise; 1=Counterclockwise
            Default:1
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - height : h                     (float)         [create,query,edit]
            Height of the helix. Default:2.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - radius : r                     (float)         [create,query,edit]
            Radius of tube. Default:0.4
        
        - roundCap : rcp                 (bool)          [create,query,edit]
            To indicate whether we need a round cap Default:false
        
        - subdivisionsAxis : sa          (int)           [create,query,edit]
            Subdivisions around the axis. Default:8
        
        - subdivisionsCaps : sc          (int)           [create,query,edit]
            Subdivisions along the thickness caps. Default:0
        
        - subdivisionsCoil : sco         (int)           [create,query,edit]
            Subdivisions along the coil. Default:50
        
        - texture : tx                   (int)           [create,query,edit]
            What texture mechanism to be applied 0=No textures; 1=Object; 2=Faces Default:2
        
        - useOldInitBehaviour : oib      (bool)          [create,query,edit]
            Create the helix with base on the origin as in Maya V8.0 and below Otherwise
            create helix centred at origin Default:false
        
        - width : w                      (float)         [create,query,edit]
            Width of the helix. Default:2.0                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyHelix`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class LightsCollection(Collection):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyWedgeFace(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Extrude faces about an axis. The axis is the average of all the selected edges.
        If the edges are not aligned, the wedge may not look intuitive.  To separately
        wedge faces about different wedge axes, the command should be issued as many
        times as the wedge axes. (as in the second example)
        
        Flags:
        - axis : ax                      (float, float, float) [create]
            This flag (along with -center) can be used instead of the -edge flag to specify
            the axis about which the wedge is performed. The flag expects three coordinates
            that form a vector about which the rotation is performed.
        
        - axisX : asx                    (float)         []
        
        - axisY : asy                    (float)         []
        
        - axisZ : asz                    (float)         []
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - center : cen                   (float, float, float) [create]
            This flag (along with -axis) can be used instead of the -edge flag to specify
            the location about which the wedge is performed. The flag expects three
            coordinates that define the center of rotation.
        
        - centerX : ctx                  (float)         []
        
        - centerY : cty                  (float)         []
        
        - centerZ : ctz                  (float)         []
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - divisions : d                  (int)           [create]
            This flag specifies the number of subdivisions along the extrusion.
        
        - edge : ed                      (int)           [create]
            This flag specifies the edgeId that should be used to perform the wedge about.
            Multiple edges can be specified. The wedge operation is performed about an axis
            that is the average of all the edges. It is recommended that only colinear edges
            are used, otherwise the result may not look intuitive. Instead of specifying the
            -edge flag, the wedge can be performed about a point and axis. See the -center
            and -axis flags for details.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - wedgeAngle : wa                (float)         [create]
            This flag specifies the angle of rotation.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyWedgeFace`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPlane(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the plane.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize and Preserve Aspect RatioDefault:1                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the plane. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height of the sphere.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getSubdivisionsWidth(self, **kwargs):
        """
        Subdivisions along the width of the plane. Default:10                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getSubdivisionsX(self, **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the plane. Default is 5.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getSubdivisionsY(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the plane. Default is 5.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getTexture(self, **kwargs):
        """
        What texture mechanism to be applied. 0=No textures; 1=stretch to fit; 2=preserve aspect ratio Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def getWidth(self, **kwargs):
        """
        Width of the plane. Default:1.0                  Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the plane.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize and Preserve Aspect RatioDefault:1                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the plane. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height of the sphere.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setSubdivisionsWidth(self, val='True', **kwargs):
        """
        Subdivisions along the width of the plane. Default:10                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setSubdivisionsX(self, val='True', **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the plane. Default is 5.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setSubdivisionsY(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the plane. Default is 5.                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        What texture mechanism to be applied. 0=No textures; 1=stretch to fit; 2=preserve aspect ratio Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        Width of the plane. Default:1.0                  Common poly creation operation flags
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a new polygonal plane.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the plane.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create,query,edit]
            Create UVs or not. 0: No UVs1: No Normalization2: Normalize and Preserve Aspect
            RatioDefault:1
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - height : h                     (float)         [create,query,edit]
            Height of the plane. Default:1.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height of the sphere.
        
        - subdivisionsWidth : sw         (int)           [create,query,edit]
            Subdivisions along the width of the plane. Default:10
        
        - subdivisionsX : sx             (int)           [create,query,edit]
            This specifies the number of subdivisions in the X direction for the plane.
            Default is 5.
        
        - subdivisionsY : sy             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Y direction for the plane.
            Default is 5.
        
        - texture : tx                   (int)           [create,query,edit]
            What texture mechanism to be applied. 0=No textures; 1=stretch to fit;
            2=preserve aspect ratio Default:1
        
        - width : w                      (float)         [create,query,edit]
            Width of the plane. Default:1.0                  Common poly creation operation
            flags
        
        
        Derived from mel command `maya.cmds.polyPlane`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMoveFacetUV(PolyMoveUV):
    def getAxisLen(self, **kwargs):
        """
        Axis Length vector, used to draw the manip handles. C: Default is 1.0, 1.0 Q: When queried, this flag returns a float[2].                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getAxisLenX(self, **kwargs):
        """
        Axis Length in X, used to draw the manip handles. C: Default is 1.0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getAxisLenY(self, **kwargs):
        """
        Axis Length in Y, used to draw the manip handles. C: Default is 1.0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getPivot(self, **kwargs):
        """
        This flag specifies the pivot for scaling and rotation. C: Default is 0.0 0.0. Q: When queried, this flag returns a float[2].                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getPivotU(self, **kwargs):
        """
        This flag specifies U for the pivot for scaling and rotation. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getPivotV(self, **kwargs):
        """
        This flag specifies V for the pivot for scaling and rotation. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getRandom(self, **kwargs):
        """
        This flag specifies the random value for all parameters. C: Default is 0.0. The range is [-10.0, 10.0]. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getRotationAngle(self, **kwargs):
        """
        Angle of rotation. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getScale(self, **kwargs):
        """
        This flag specifies the scaling vector. C: Default is 1.0 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getScaleU(self, **kwargs):
        """
        This flag specifies U for the scaling vector. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getScaleV(self, **kwargs):
        """
        This flag specifies V for the scaling vector. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getTranslate(self, **kwargs):
        """
        This flag specifies the translation vector. C: Default is 0.0 0.0. Q: When queried, this flag returns a float[2].                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getTranslateU(self, **kwargs):
        """
        This flag specifies the U translation vector. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def getTranslateV(self, **kwargs):
        """
        This flag specifies the V translation vector. C: Default is 0.0. Q: When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setAxisLen(self, val='True', **kwargs):
        """
        Axis Length vector, used to draw the manip handles. C: Default is 1.0, 1.0 Q: When queried, this flag returns a float[2].                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setAxisLenX(self, val='True', **kwargs):
        """
        Axis Length in X, used to draw the manip handles. C: Default is 1.0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setAxisLenY(self, val='True', **kwargs):
        """
        Axis Length in Y, used to draw the manip handles. C: Default is 1.0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        This flag specifies the pivot for scaling and rotation. C: Default is 0.0 0.0. Q: When queried, this flag returns a float[2].                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setPivotU(self, val='True', **kwargs):
        """
        This flag specifies U for the pivot for scaling and rotation. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setPivotV(self, val='True', **kwargs):
        """
        This flag specifies V for the pivot for scaling and rotation. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setRandom(self, val='True', **kwargs):
        """
        This flag specifies the random value for all parameters. C: Default is 0.0. The range is [-10.0, 10.0]. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setRotationAngle(self, val='True', **kwargs):
        """
        Angle of rotation. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        This flag specifies the scaling vector. C: Default is 1.0 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setScaleU(self, val='True', **kwargs):
        """
        This flag specifies U for the scaling vector. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setScaleV(self, val='True', **kwargs):
        """
        This flag specifies V for the scaling vector. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setTranslate(self, val='True', **kwargs):
        """
        This flag specifies the translation vector. C: Default is 0.0 0.0. Q: When queried, this flag returns a float[2].                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setTranslateU(self, val='True', **kwargs):
        """
        This flag specifies the U translation vector. C: Default is 0.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    def setTranslateV(self, val='True', **kwargs):
        """
        This flag specifies the V translation vector. C: Default is 0.0. Q: When queried, this flag returns a float.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Modifies the map by moving all UV values associated with the selected face(s).
        The UV coordinates of the model are manipulated without changing the vertices of
        the 3D object.
        
        Flags:
        - axisLen : l                    (float, float)  [create,query,edit]
            Axis Length vector, used to draw the manip handles. C: Default is 1.0, 1.0 Q:
            When queried, this flag returns a float[2].
        
        - axisLenX : lx                  (float)         [create,query,edit]
            Axis Length in X, used to draw the manip handles. C: Default is 1.0 Q: When
            queried, this flag returns a float.
        
        - axisLenY : ly                  (float)         [create,query,edit]
            Axis Length in Y, used to draw the manip handles. C: Default is 1.0 Q: When
            queried, this flag returns a float.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - pivot : pvt                    (float, float)  [create,query,edit]
            This flag specifies the pivot for scaling and rotation. C: Default is 0.0 0.0.
            Q: When queried, this flag returns a float[2].
        
        - pivotU : pvu                   (float)         [create,query,edit]
            This flag specifies U for the pivot for scaling and rotation. C: Default is 0.0.
            Q: When queried, this flag returns a float.
        
        - pivotV : pvv                   (float)         [create,query,edit]
            This flag specifies V for the pivot for scaling and rotation. C: Default is 0.0.
            Q: When queried, this flag returns a float.
        
        - random : ran                   (float)         [create,query,edit]
            This flag specifies the random value for all parameters. C: Default is 0.0. The
            range is [-10.0, 10.0]. Q: When queried, this flag returns a float.
        
        - rotationAngle : ra             (float)         [create,query,edit]
            Angle of rotation. C: Default is 0.0. Q: When queried, this flag returns a
            float.
        
        - scale : s                      (float, float)  [create,query,edit]
            This flag specifies the scaling vector. C: Default is 1.0 1.0. Q: When queried,
            this flag returns a float.
        
        - scaleU : su                    (float)         [create,query,edit]
            This flag specifies U for the scaling vector. C: Default is 1.0. Q: When
            queried, this flag returns a float.
        
        - scaleV : sv                    (float)         [create,query,edit]
            This flag specifies V for the scaling vector. C: Default is 1.0. Q: When
            queried, this flag returns a float.
        
        - translate : t                  (float, float)  [create,query,edit]
            This flag specifies the translation vector. C: Default is 0.0 0.0. Q: When
            queried, this flag returns a float[2].
        
        - translateU : tu                (float)         [create,query,edit]
            This flag specifies the U translation vector. C: Default is 0.0. Q: When
            queried, this flag returns a float.
        
        - translateV : tv                (float)         [create,query,edit]
            This flag specifies the V translation vector. C: Default is 0.0. Q: When
            queried, this flag returns a float.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMoveFacetUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPlatonicSolid(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the platonic solid. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def getRadius(self, **kwargs):
        """
        This flag specifies the radius of the platonic solid. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def getSideLength(self, **kwargs):
        """
        This flag specifies the side length of platonic solid. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the platonic solid. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        This flag specifies the radius of the platonic solid. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    def setSideLength(self, val='True', **kwargs):
        """
        This flag specifies the side length of platonic solid. C: Default is 1.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The polyPlatonicSolid command creates a new polygonal platonic solid.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the platonic solid. Q: When
            queried, this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create]
            This flag alows a specific UV mechanism to be selected, while creating. The
            valid values are 0, 1,  2 ,3 or 4. 0 implies that no UVs will be generated (No
            texture to be applied). 1 implies UVs should be created for the object as a
            whole without any normalization. The solid will be unwrapped and then the
            texture will be applied without any distortion. In the unwrapped solid, the
            shared edges will have shared UVs. 2 implies UVs are created separately for each
            of the faces of the solid. 3 implies the UVs should be normalized. This will
            normalize the U and V direction separately, thereby resulting in distortion of
            textures. 4 implies UVs are created so that the texture will not be distorted
            when applied. The texture lying outside the UV range will be truncated (since
            that cannot be squeezed in, without distorting the texture. For better
            understanding of these options, you may have to open the texture view windowC:
            Default is 4
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - radius : r                     (float)         [create,query,edit]
            This flag specifies the radius of the platonic solid. C: Default is 1.0. Q: When
            queried, this flag returns a float.
        
        - sideLength : l                 (float)         [create,query,edit]
            This flag specifies the side length of platonic solid. C: Default is 1.0. Q:
            When queried, this flag returns a float.
        
        - solidType : st                 (int)           [create]
            This flag allows a specific platonic solid to be selected for creation of mesh,
            The valid values are 0, 1, 2 and 3. 0 implies dodecahedron to be created. 1
            implies icosahedron to be created. 2 implies octahedron to be created. 3 implies
            tertrahedron to be created. C: Default is 0
        
        - texture : tx                   (int)           [create]
            This flag is obsolete and will be removed in the next release. The
            -cuv/createUVs flag should be used instead.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyPlatonicSolid`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Phong(Reflect):
    def getCosPower(self):
        """
        Retrieves the value of the "cosPower" attribute of a phong shader node. This attribute determines the size of specular highlights produced by the shader.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnPhongShader.cosPower`
        """
        pass
    def setCosPower(self, cos_power):
        """
        Sets the value of the "cosPower" attribute of a shader node.
        
        Parameters:
        cos_power : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnPhongShader.setCosPower`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPrimitiveMisc(PolyPrimitive):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Dynamic library stub function 
        
        
        Derived from mel command `maya.cmds.polyPrimitiveMisc`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPrism(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the prism. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getLength(self, **kwargs):
        """
        This flag specifies the length of the prism. C: Default is 2.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getNumberOfSides(self, **kwargs):
        """
        This specifies the number of sides for the prism. C: Default is 3. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getNumderOfSides(self, **kwargs):
        """
        This specifies the number of sides for the prism. C: Default is 3. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getSideLength(self, **kwargs):
        """
        This flag specifies the edge length of the prism. C: Default is 2.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getSubdivisionsCaps(self, **kwargs):
        """
        This flag specifies the subdivisions on the caps for the prism. C: Default is 2. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        This specifies the subdivisions along the height for the prism. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the prism. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setLength(self, val='True', **kwargs):
        """
        This flag specifies the length of the prism. C: Default is 2.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setNumberOfSides(self, val='True', **kwargs):
        """
        This specifies the number of sides for the prism. C: Default is 3. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setNumderOfSides(self, val='True', **kwargs):
        """
        This specifies the number of sides for the prism. C: Default is 3. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setSideLength(self, val='True', **kwargs):
        """
        This flag specifies the edge length of the prism. C: Default is 2.0. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setSubdivisionsCaps(self, val='True', **kwargs):
        """
        This flag specifies the subdivisions on the caps for the prism. C: Default is 2. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        This specifies the subdivisions along the height for the prism. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The prism command creates a new polygonal prism.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the prism. Q: When queried,
            this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create]
            This flag alows a specific UV mechanism to be selected, while creating the
            primitive. The valid values are 0, 1,  2 or 3. 0 implies that no UVs will be
            generated (No texture to be applied). 1 implies UVs should be created for the
            object as a whole without any normalization. The primitive will be unwrapped and
            then the texture will be applied without any distortion. In the unwrapped
            primitive, the shared edges will have shared UVs. 2 implies the UVs should be
            normalized. This will normalize the U and V direction separately, thereby
            resulting in distortion of textures. 3 implies UVs are created so that the
            texture will not be distorted when applied. The texture lying outside the UV
            range will be truncated (since that cannot be squeezed in, without distorting
            the texture. For better understanding of these options, you may have to open the
            texture view windowC: Default is 2.
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - length : l                     (float)         [create,query,edit]
            This flag specifies the length of the prism. C: Default is 2.0. Q: When queried,
            this flag returns a float.
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - numberOfSides : ns             (int)           [create,query,edit]
            This specifies the number of sides for the prism. C: Default is 3. Q: When
            queried, this flag returns an int.
        
        - numderOfSides : nsi            (int)           [create,query,edit]
            This specifies the number of sides for the prism. C: Default is 3. Q: When
            queried, this flag returns an int.
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - sideLength : w                 (float)         [create,query,edit]
            This flag specifies the edge length of the prism. C: Default is 2.0. Q: When
            queried, this flag returns a float.
        
        - subdivisionsCaps : sc          (int)           [create,query,edit]
            This flag specifies the subdivisions on the caps for the prism. C: Default is 2.
            Q: When queried, this flag returns an int.
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            This specifies the subdivisions along the height for the prism. C: Default is 1.
            Q: When queried, this flag returns an int.
        
        - texture : tx                   (int)           [create]
            This flag is obsolete and will be removed in the next release. The
            -cuv/createUVs flag should be used instead.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyPrism`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPoke(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Introduces a new vertex in the middle of the selected face, and connects it to
        the rest of the vertices of the face.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - localTranslate : lt            (float, float, float) [create]
            Translate the new vertex in the local face coordinate.
        
        - localTranslateX : ltx          (float)         [create]
            Translate the new vertex in the local face coordinate along X.
        
        - localTranslateY : lty          (float)         [create]
            Translate the new vertex in the local face coordinate along Y.
        
        - localTranslateZ : ltz          (float)         [create]
            Translate the new vertex in the local face coordinate along Z.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - translate : t                  (float, float, float) [create]
            Translate the new vertex in the world space.
        
        - translateX : tx                (float)         [create]
            Translate the new vertex in the world space along X.
        
        - translateY : ty                (float)         [create]
            Translate the new vertex in the world space along Y.
        
        - translateZ : tz                (float)         [create]
            Translate the new vertex in the world space along Z.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyPoke`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NurbsToSubdivProc(NurbsToSubdiv):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPyramid(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the pyramid. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getNumberOfSides(self, **kwargs):
        """
        Number of sides of Pyramid. Default:4                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getNumderOfSides(self, **kwargs):
        """
        Number of sides of Pyramid. Default:4                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getSideLength(self, **kwargs):
        """
        Side length of the Pyramid. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getSubdivisionsCaps(self, **kwargs):
        """
        Subdivisions on bottom cap Default:0                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def getTexture(self, **kwargs):
        """
        Apply texture or not. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the pyramid. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setNumberOfSides(self, val='True', **kwargs):
        """
        Number of sides of Pyramid. Default:4                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setNumderOfSides(self, val='True', **kwargs):
        """
        Number of sides of Pyramid. Default:4                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setSideLength(self, val='True', **kwargs):
        """
        Side length of the Pyramid. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setSubdivisionsCaps(self, val='True', **kwargs):
        """
        Subdivisions on bottom cap Default:0                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        Apply texture or not. Default:true                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The pyramid command creates a new polygonal pyramid.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the pyramid. Q: When
            queried, this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create,query,edit]
            Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and
            Preserve Aspect RatioDefault:2
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - numberOfSides : ns             (int)           [create,query,edit]
            Number of sides of Pyramid. Default:4
        
        - numderOfSides : nsi            (int)           [create,query,edit]
            Number of sides of Pyramid. Default:4
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - sideLength : w                 (float)         [create,query,edit]
            Side length of the Pyramid. Default:1.0
        
        - subdivisionsCaps : sc          (int)           [create,query,edit]
            Subdivisions on bottom cap Default:0
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height. Default:1
        
        - texture : tx                   (bool)          [create,query,edit]
            Apply texture or not. Default:true                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyPyramid`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BakeSet(ObjectSet):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyTorus(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the torus. Q: When queried, this flag returns a vector.                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getRadius(self, **kwargs):
        """
        Radius of the torus. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getSectionRadius(self, **kwargs):
        """
        Section of the torus. Default:0.50                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getSubdivisionsAxis(self, **kwargs):
        """
        Subdivisions about the vertical axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getSubdivisionsX(self, **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the torus (number of sections). C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getSubdivisionsY(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the torus (number of segments per section). C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getTexture(self, **kwargs):
        """
        Apply texture or not. this is an old attribute. This is unsupported and would be removed in a future release. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def getTwist(self, **kwargs):
        """
        Twist angle of the torus. Default:0.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the torus. Q: When queried, this flag returns a vector.                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        Radius of the torus. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setSectionRadius(self, val='True', **kwargs):
        """
        Section of the torus. Default:0.50                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setSubdivisionsAxis(self, val='True', **kwargs):
        """
        Subdivisions about the vertical axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setSubdivisionsX(self, val='True', **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the torus (number of sections). C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setSubdivisionsY(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the torus (number of segments per section). C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        Apply texture or not. this is an old attribute. This is unsupported and would be removed in a future release. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    def setTwist(self, val='True', **kwargs):
        """
        Twist angle of the torus. Default:0.0                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The torus command creates a new polygonal torus.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the torus. Q: When queried,
            this flag returns a vector.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (bool)          [create,query,edit]
            Create UVs or not. Default:true
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - radius : r                     (float)         [create,query,edit]
            Radius of the torus. Default:1.0
        
        - sectionRadius : sr             (float)         [create,query,edit]
            Section of the torus. Default:0.50
        
        - subdivisionsAxis : sa          (int)           [create,query,edit]
            Subdivisions about the vertical axis. Default:20
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height. Default:20
        
        - subdivisionsX : sx             (int)           [create,query,edit]
            This specifies the number of subdivisions in the X direction for the torus
            (number of sections). C: Default is 20. Q: When queried, this flag returns an
            int.
        
        - subdivisionsY : sy             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Y direction for the torus
            (number of segments per section). C: Default is 20. Q: When queried, this flag
            returns an int.
        
        - texture : tx                   (bool)          [create,query,edit]
            Apply texture or not. this is an old attribute. This is unsupported and would be
            removed in a future release. Default:true
        
        - twist : tw                     (float)         [create,query,edit]
            Twist angle of the torus. Default:0.0                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyTorus`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderSettingsCollection(Collection):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class LightsChildCollection(Collection):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyProj(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class AovCollection(Collection):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPipe(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the pipe. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the pipe. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getRadius(self, **kwargs):
        """
        Radius of the pipe. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getRoundCap(self, **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getSubdivisionsAxis(self, **kwargs):
        """
        Subdivisions around the axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getSubdivisionsCaps(self, **kwargs):
        """
        Subdivisions along the thickness caps. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getTexture(self, **kwargs):
        """
        Apply texture or not. this is an old attribute. This is unsupported and would be removed in a future release. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def getThickness(self, **kwargs):
        """
        Thickness of the pipe. Default:0.5                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the pipe. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the pipe. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        Radius of the pipe. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setRoundCap(self, val='True', **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setSubdivisionsAxis(self, val='True', **kwargs):
        """
        Subdivisions around the axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setSubdivisionsCaps(self, val='True', **kwargs):
        """
        Subdivisions along the thickness caps. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        Apply texture or not. this is an old attribute. This is unsupported and would be removed in a future release. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    def setThickness(self, val='True', **kwargs):
        """
        Thickness of the pipe. Default:0.5                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The polyPipe command creates a new polygonal pipe.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the pipe. Q: When queried,
            this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (bool)          [create,query,edit]
            Create UVs or not. Default:true
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - height : h                     (float)         [create,query,edit]
            Height of the pipe. Default:2.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - radius : r                     (float)         [create,query,edit]
            Radius of the pipe. Default:1.0
        
        - roundCap : rcp                 (bool)          [create,query,edit]
            To indicate whether we need a round cap Default:false
        
        - subdivisionsAxis : sa          (int)           [create,query,edit]
            Subdivisions around the axis. Default:20
        
        - subdivisionsCaps : sc          (int)           [create,query,edit]
            Subdivisions along the thickness caps. Default:1
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height. Default:1
        
        - texture : tx                   (bool)          [create,query,edit]
            Apply texture or not. this is an old attribute. This is unsupported and would be
            removed in a future release. Default:true
        
        - thickness : t                  (float)         [create,query,edit]
            Thickness of the pipe. Default:0.5                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyPipe`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyRemesh(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def getInterpolationType(self, **kwargs):
        """
        Algorithm used for interpolating new vertices                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def getReduceThreshold(self, **kwargs):
        """
        A percentage of the refineThreshold. Edges shorter than this percentage will be reduced to a single vertex.                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def getRefineThreshold(self, **kwargs):
        """
        Triangle edges longer than this value will be split into two edges.                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def getSmoothStrength(self, **kwargs):
        """
        Amount of smoothing applied to the vertices after remeshing.                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def getTessellateBorders(self, **kwargs):
        """
        Specifies if the borders of the selected region are allowed to be remeshed.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def setInterpolationType(self, val='True', **kwargs):
        """
        Algorithm used for interpolating new vertices                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def setReduceThreshold(self, val='True', **kwargs):
        """
        A percentage of the refineThreshold. Edges shorter than this percentage will be reduced to a single vertex.                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def setRefineThreshold(self, val='True', **kwargs):
        """
        Triangle edges longer than this value will be split into two edges.                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def setSmoothStrength(self, val='True', **kwargs):
        """
        Amount of smoothing applied to the vertices after remeshing.                  
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    def setTessellateBorders(self, val='True', **kwargs):
        """
        Specifies if the borders of the selected region are allowed to be remeshed.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Triangulates, then remeshes the given mesh through edge splitting and
        collapsing. Edges longer than the specified refinement threshold are split, and
        edges shorter than the reduction threshold are collapsed.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - interpolationType : ipt        (int)           [create,query,edit]
            Algorithm used for interpolating new vertices
        
        - maxTriangleCount : mtc         (int)           []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - reduceThreshold : rdt          (float)         [create,query,edit]
            A percentage of the refineThreshold. Edges shorter than this percentage will be
            reduced to a single vertex.
        
        - refineThreshold : rft          (float)         [create,query,edit]
            Triangle edges longer than this value will be split into two edges.
        
        - smoothStrength : smt           (float)         [create,query,edit]
            Amount of smoothing applied to the vertices after remeshing.
        
        - tessellateBorders : tsb        (bool)          [create,query,edit]
            Specifies if the borders of the selected region are allowed to be remeshed.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        - worldSpace : ws                (bool)          []
        
        
        Derived from mel command `maya.cmds.polyRemesh`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PsdFileTex(File):
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbCone(RevolvedPrimitive):
    def getAxis(self, **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getEndSweep(self, **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getHeightRatio(self, **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getRadius(self, **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getSections(self, **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getSpans(self, **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getStartSweep(self, **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getUseOldInitBehaviour(self, **kwargs):
        """
        Create the cone with base on the origin as in Maya V8.0 and below Otherwise create cone centred at origin Default:false                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def getUseTolerance(self, **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setEndSweep(self, val='True', **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setHeightRatio(self, val='True', **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setSections(self, val='True', **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setSpans(self, val='True', **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setStartSweep(self, val='True', **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setUseOldInitBehaviour(self, val='True', **kwargs):
        """
        Create the cone with base on the origin as in Maya V8.0 and below Otherwise create cone centred at origin Default:false                  
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    def setUseTolerance(self, val='True', **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The cone command creates a new cone and/or a dependency node that creates one,
        and returns their names.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            The primitive's axis
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface: 1 - linear, 3 - cubic Default:3
        
        - endSweep : esw                 (float)         [create,query,edit]
            The angle at which to end the surface of revolution. Default is 2Pi radians, or
            360 degrees. Default:6.2831853
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - heightRatio : hr               (float)         [create,query,edit]
            Ratio of heightto widthDefault:2.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - pivot : p                      (float, float, float) [create,query,edit]
            The primitive's pivot point
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        - radius : r                     (float)         [create,query,edit]
            The radius of the object Default:1.0
        
        - sections : s                   (int)           [create,query,edit]
            The number of sections determines the resolution of the surface in the sweep
            direction. Used only if useTolerance is false. Default:8
        
        - spans : nsp                    (int)           [create,query,edit]
            The number of spans determines the resolution of the surface in the opposite
            direction. Default:1
        
        - startSweep : ssw               (float)         [create,query,edit]
            The angle at which to start the surface of revolution Default:0
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to build the surface. Used only if useTolerance is true
            Default:0.01
        
        - useOldInitBehaviour : oib      (bool)          [create,query,edit]
            Create the cone with base on the origin as in Maya V8.0 and below Otherwise
            create cone centred at origin Default:false
        
        - useTolerance : ut              (bool)          [create,query,edit]
            Use the specified tolerance to determine resolution. Otherwise number of
            sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.cone`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'cone'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySphProj(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySplitVert(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbCylinder(RevolvedPrimitive):
    def getAxis(self, **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getEndSweep(self, **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getHeightRatio(self, **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getRadius(self, **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getSections(self, **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getSpans(self, **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getStartSweep(self, **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def getUseTolerance(self, **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setEndSweep(self, val='True', **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setHeightRatio(self, val='True', **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setSections(self, val='True', **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setSpans(self, val='True', **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setStartSweep(self, val='True', **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    def setUseTolerance(self, val='True', **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The cylinder command creates a new cylinder and/or a dependency node that
        creates one, and returns their names.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            The primitive's axis
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface: 1 - linear, 3 - cubic Default:3
        
        - endSweep : esw                 (float)         [create,query,edit]
            The angle at which to end the surface of revolution. Default is 2Pi radians, or
            360 degrees. Default:6.2831853
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - heightRatio : hr               (float)         [create,query,edit]
            Ratio of heightto widthDefault:2.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - pivot : p                      (float, float, float) [create,query,edit]
            The primitive's pivot point
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        - radius : r                     (float)         [create,query,edit]
            The radius of the object Default:1.0
        
        - sections : s                   (int)           [create,query,edit]
            The number of sections determines the resolution of the surface in the sweep
            direction. Used only if useTolerance is false. Default:8
        
        - spans : nsp                    (int)           [create,query,edit]
            The number of spans determines the resolution of the surface in the opposite
            direction. Default:1
        
        - startSweep : ssw               (float)         [create,query,edit]
            The angle at which to start the surface of revolution Default:0
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to build the surface. Used only if useTolerance is true
            Default:0.01
        
        - useTolerance : ut              (bool)          [create,query,edit]
            Use the specified tolerance to determine resolution. Otherwise number of
            sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.cylinder`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'cylinder'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Character(ObjectSet):
    def addElement(self, val='True', **kwargs):
        """
        Adds the list of items to the given character.  If some of the items cannot be added to the character because they are in another character, the command will fail.  When another character is passed to to -addElement, is is added as a sub character.  When a node is passed in, it is expanded into its keyable attributes, which are then added to the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def blendExists(self, instancedClip1, instancedClip2, blendResult):
        """
        Return true if a blend exists between the two instanced clips on the character. If a blend exists, the animBlend node related to the blend is also returned.
        
        Parameters:
        instancedClip1 : 'PyNode'
            clip
        instancedClip2 : 'PyNode'
            another clip
        blendResult : 'PyNode'
            the blend, if a blend is found
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.blendExists`
        """
        pass
    def flatten(self, val='True', **kwargs):
        """
        An operation that flattens the structure of the given character. That is, any characters contained by the given character will be replaced by its members so that the character no longer contains other characters but contains the other characters' members.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getAddOffsetObject(self, **kwargs):
        """
        Indicates that the selected character member objects should be used when calculating and applying offsets. The flag argument is used to specify the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getBlend(self, index):
        """
        Return the animBlendInOut node corresponding to the specified index.
        
        Parameters:
        index : 'int'
            Index of the desired node.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getBlend`
        """
        pass
    def getBlendClips(self, index):
        """
        Returns the clip nodes that are blended by the blend node corresponding to the specified index.
        
        Parameters:
        index : 'int'
            the index of the blend
        
        
        Returns:
        Tuple['PyNode', 'PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getBlendClips`
        """
        pass
    def getBlendCount(self):
        """
        Return the number of blends that have been added to clips on this character.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getBlendCount`
        """
        pass
    def getCharacterPlug(self, **kwargs):
        """
        Returns the plug on the character that corresponds to the specified character member.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getCharacterThatOwnsPlug(self, plug, result):
        """
        Given a plug, test the plug to see if it is owned by a character. If a character controls this plug, the character will be returned
        
        Parameters:
        plug : 'PyNode'
            MPlug containing a plug for which you want to find the related character
        result : 'PyNode'
            Mobject containing a character if the plug is in a character, else an empty MObject
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getCharacterThatOwnsPlug`
        """
        pass
    def getClipScheduler(self):
        """
        Get the clipScheduler node that manages the playback of clips on this character. If no clips have been created for this character, this method will return an empty MObject.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getClipScheduler`
        """
        pass
    def getIsIntersecting(self, **kwargs):
        """
        An operation which tests whether or not the characters in the list have common members.  In general, characters should be mutually exclusive, so this should always return false.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getIsMember(self, **kwargs):
        """
        An operation which tests whether or not all the given items are members of the given character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getLibrary(self, **kwargs):
        """
        Returns the clip library associated with this character, if there is one. A clip library will only exist if you have created clips on your character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getMemberIndex(self, **kwargs):
        """
        Returns the memberIndex of the specified character member if used after the query flag. Or if used before the query flag, returns the member that corresponds to the specified index.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getMemberPlugs(self):
        """
        Get the members of the character set that are attributes. Return them as a plug array. A character set can contain only attributes and subcharacters. To get all of the members of the character, use MFnSet::getMembers. To get the subcharacters, use MFnCharacter::getSubcharacters.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getMemberPlugs`
        """
        pass
    def getNodesOnly(self, **kwargs):
        """
        This flag modifies the results of character membership queries. When listing the attributes (e.g. sphere1.tx) contained in the character, list only the nodes.  Each node will only be listed once, even if more than one attribute or component of the node exists in the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getOffsetNode(self, **kwargs):
        """
        Returns the name of the characterOffset node used to add offsets to the root of the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getScheduledClip(self, index):
        """
        Return the scheduled animClip node corresponding to the specified index. The specified index should range from 0 to clipCount-1 where clipCount is the value returned by MFnCharacter::getScheduledClipCount.
        
        Parameters:
        index : 'int'
            Clip index.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getScheduledClip`
        """
        pass
    def getScheduledClipCount(self):
        """
        Return the number of clips that have been scheduled on this character.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getScheduledClipCount`
        """
        pass
    def getScheduler(self, **kwargs):
        """
        Returns the scheduler associated with this character, if there is one. A scheduler will only exist if you have created clips on your character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getSourceClip(self, index):
        """
        Return the animClip node corresponding to the specified index. The animClip node will be a source clip node. The specified index should range from 0 to clipCount-1 where clipCount is the value returned by MFnCharacter::getSourceClipCount.
        
        Parameters:
        index : 'int'
            Clip index.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getSourceClip`
        """
        pass
    def getSourceClipCount(self):
        """
        Return the number of source clips managed by the clipLibrary node of this character. For more information on source clips, refer to the description of the MFnCharacter node.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getSourceClipCount`
        """
        pass
    def getSubCharacters(self):
        """
        Get a list of the subcharacters that are members of the character set.
        
        Returns:
        'SelectionSet'
        
        Derived from api method `maya.OpenMayaAnim.MFnCharacter.getSubCharacters`
        """
        pass
    def getSubtract(self, **kwargs):
        """
        An operation between two characters which returns the members of the first character that are not in the second character. In general, characters should be mutually exclusive.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getText(self, **kwargs):
        """
        Defines an annotation string to be stored with the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def getUserAlias(self, **kwargs):
        """
        Returns the user defined alias for the given attribute on the character or and empty string if there is not one.  Characters automatically alias the attributes where character animation data is stored.  A user alias will exist when the automatic aliases are overridden using the aliasAttr command.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def include(self, val='True', **kwargs):
        """
        Adds the list of items to the given character.  If some of the items cannot be added to the character, a warning will be issued. This is a less strict version of the -add/addElement operation.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def removeOffsetObject(self, val='True', **kwargs):
        """
        Indicates that the selected character offset objects should be removed as offsets. The flag argument is used to specify the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def setAddOffsetObject(self, val='True', **kwargs):
        """
        Indicates that the selected character member objects should be used when calculating and applying offsets. The flag argument is used to specify the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        Defines an annotation string to be stored with the character.                  
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to manage the membership of a character.  Characters are a
        type of set that gathers together the attributes of a node or nodes that a user
        wishes to animate as a single entity.
        
        Flags:
        - addElement : add               (PyNode)        [edit]
            Adds the list of items to the given character.  If some of the items cannot be
            added to the character because they are in another character, the command will
            fail.  When another character is passed to to -addElement, is is added as a sub
            character.  When a node is passed in, it is expanded into its keyable
            attributes, which are then added to the character.
        
        - addOffsetObject : aoo          (unicode)       [query,edit]
            Indicates that the selected character member objects should be used when
            calculating and applying offsets. The flag argument is used to specify the
            character.
        
        - characterPlug : cp             (bool)          [query]
            Returns the plug on the character that corresponds to the specified character
            member.
        
        - clear : cl                     (PyNode)        [edit]
            An operation which removes all items from the given character.
        
        - empty : em                     (bool)          [create]
            Indicates that the character to be created should be empty. (i.e. it ignores any
            arguments identifying objects to be added to the character.
        
        - excludeDynamic : ed            (bool)          [create]
            When creating the character, exclude dynamic attributes.
        
        - excludeRotate : er             (bool)          [create]
            When creating the character, exclude rotate attributes from transform-type
            nodes.
        
        - excludeScale : es              (bool)          [create]
            When creating the character, exclude scale attributes from transform-type nodes.
        
        - excludeTranslate : et          (bool)          [create]
            When creating the character, exclude translate attributes from transform-type
            nodes. For example, if your character contains joints only, perhaps you only
            want to include rotations in the character.
        
        - excludeVisibility : ev         (bool)          [create]
            When creating the character, exclude visibility attribute from transform-type
            nodes.
        
        - flatten : fl                   (PyNode)        [edit]
            An operation that flattens the structure of the given character. That is, any
            characters contained by the given character will be replaced by its members so
            that the character no longer contains other characters but contains the other
            characters' members.
        
        - forceElement : fe              (PyNode)        [edit]
            For use in edit mode only. Forces addition of the items to the character. If the
            items are in another character which is in the character partition, the items
            will be removed from the other character in order to keep the characters in the
            character partition mutually exclusive with respect to membership.
        
        - include : include              (PyNode)        [edit]
            Adds the list of items to the given character.  If some of the items cannot be
            added to the character, a warning will be issued. This is a less strict version
            of the -add/addElement operation.
        
        - intersection : int             (PyNode)        [query]
            An operation that returns a list of items which are members of all the character
            in the list.  In general, characters should be mutually exclusive.
        
        - isIntersecting : ii            (PyNode)        [query]
            An operation which tests whether or not the characters in the list have common
            members.  In general, characters should be mutually exclusive, so this should
            always return false.
        
        - isMember : im                  (PyNode)        [query]
            An operation which tests whether or not all the given items are members of the
            given character.
        
        - library : lib                  (bool)          [query]
            Returns the clip library associated with this character, if there is one. A clip
            library will only exist if you have created clips on your character.
        
        - memberIndex : mi               (int)           [query]
            Returns the memberIndex of the specified character member if used after the
            query flag. Or if used before the query flag, returns the member that
            corresponds to the specified index.
        
        - name : n                       (unicode)       [create]
            Assigns string as the name for a new character. Valid for operations that create
            a new character.
        
        - noWarnings : nw                (bool)          [create]
            Indicates that warning messages should not be reported such as when trying to
            add an invalid item to a character. (used by UI)
        
        - nodesOnly : no                 (bool)          [query]
            This flag modifies the results of character membership queries. When listing the
            attributes (e.g. sphere1.tx) contained in the character, list only the nodes.
            Each node will only be listed once, even if more than one attribute or component
            of the node exists in the character.
        
        - offsetNode : ofs               (bool)          [query]
            Returns the name of the characterOffset node used to add offsets to the root of
            the character.
        
        - remove : rm                    (PyNode)        [edit]
            Removes the list of items from the given character.
        
        - removeOffsetObject : roo       (unicode)       [edit]
            Indicates that the selected character offset objects should be removed as
            offsets. The flag argument is used to specify the character.
        
        - root : rt                      (unicode)       [create]
            Specifies the transform node which will act as the root of the character being
            created. This creates a characterOffset node in addition to the character node,
            which can be used to add offsets to the character to change the direction of the
            character's animtion without inserting additional nodes in its hierarchy.
        
        - scheduler : sc                 (bool)          [query]
            Returns the scheduler associated with this character, if there is one. A
            scheduler will only exist if you have created clips on your character.
        
        - split : sp                     (PyNode)        [create]
            Produces a new set with the list of items and removes each item in the list of
            items from the given set.
        
        - subtract : sub                 (PyNode)        [query]
            An operation between two characters which returns the members of the first
            character that are not in the second character. In general, characters should be
            mutually exclusive.
        
        - text : t                       (unicode)       [create,query,edit]
            Defines an annotation string to be stored with the character.
        
        - union : un                     (PyNode)        [query]
            An operation that returns a list of all the members of all characters listed.
        
        - userAlias : ua                 (PyNode)        [query]
            Returns the user defined alias for the given attribute on the character or and
            empty string if there is not one.  Characters automatically alias the attributes
            where character animation data is stored.  A user alias will exist when the
            automatic aliases are overridden using the aliasAttr command.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.character`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyBoolOp(PolyUnite):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def getFaceAreaThreshold(self, **kwargs):
        """
        Area threshold to determine whether faces should be collapsed before boolean. Attribute is ignored unless useThresholds is set to true Default:0.0001                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def getMergeUVSets(self, **kwargs):
        """
        Specify how UV sets will be merged on the output mesh. 0 = No Merge: Each UV set on each mesh will become a new UV set in the output.1 = Merge By Name: UV sets with the same name will be merged.2 = Merge By UV Links: UV sets will be merged so that UV linking on the input meshes continues to work.The default is merge by name.                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def getOperation(self, **kwargs):
        """
        Boolean operation type. 1=union, 2=difference, 3=intersection. Default type is union. Default:kBoolOpUnion                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def getPreserveColor(self, **kwargs):
        """
        If true, boolean op will compute color for the new mesh. If false, the new mesh won't have any color set. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def getUseThresholds(self, **kwargs):
        """
        If true, merge vertices with separations less then vertexDistanceThreshold and collapse faces with areas less then faceAreaThreshold. If false, do not merge vertices or collapse faces Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def getVertexDistanceThreshold(self, **kwargs):
        """
        Tolerance to determine whether vertices (and edges) should be merged before boolean operation is applied. Attribute is ignored unless useThresholds is set to true Default:0.001                  Flags from polyCBoolOpFlags From polyUnite Node
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setFaceAreaThreshold(self, val='True', **kwargs):
        """
        Area threshold to determine whether faces should be collapsed before boolean. Attribute is ignored unless useThresholds is set to true Default:0.0001                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setMergeUVSets(self, val='True', **kwargs):
        """
        Specify how UV sets will be merged on the output mesh. 0 = No Merge: Each UV set on each mesh will become a new UV set in the output.1 = Merge By Name: UV sets with the same name will be merged.2 = Merge By UV Links: UV sets will be merged so that UV linking on the input meshes continues to work.The default is merge by name.                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setOperation(self, val='True', **kwargs):
        """
        Boolean operation type. 1=union, 2=difference, 3=intersection. Default type is union. Default:kBoolOpUnion                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setPreserveColor(self, val='True', **kwargs):
        """
        If true, boolean op will compute color for the new mesh. If false, the new mesh won't have any color set. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setUseThresholds(self, val='True', **kwargs):
        """
        If true, merge vertices with separations less then vertexDistanceThreshold and collapse faces with areas less then faceAreaThreshold. If false, do not merge vertices or collapse faces Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    def setVertexDistanceThreshold(self, val='True', **kwargs):
        """
        Tolerance to determine whether vertices (and edges) should be merged before boolean operation is applied. Attribute is ignored unless useThresholds is set to true Default:0.001                  Flags from polyCBoolOpFlags From polyUnite Node
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a new poly as the result of a boolean operation on input
        polys : union, intersection, difference. Only for difference, the order of the
        selected objects is important : result = object1 - object2. If no objects are
        specified in the command line, then the objects from the active list are used.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - classification : cls           (int)           []
        
        - constructionHistory : ch       (bool)          []
        
        - faceAreaThreshold : fat        (float)         [create,query,edit]
            Area threshold to determine whether faces should be collapsed before boolean.
            Attribute is ignored unless useThresholds is set to true Default:0.0001
        
        - frozen : fzn                   (bool)          []
        
        - mergeUVSets : muv              (int)           [create,query,edit]
            Specify how UV sets will be merged on the output mesh. 0 = No Merge: Each UV set
            on each mesh will become a new UV set in the output.1 = Merge By Name: UV sets
            with the same name will be merged.2 = Merge By UV Links: UV sets will be merged
            so that UV linking on the input meshes continues to work.The default is merge by
            name.
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - object : o                     (bool)          []
        
        - operation : op                 (int)           [create,query,edit]
            Boolean operation type. 1=union, 2=difference, 3=intersection. Default type is
            union. Default:kBoolOpUnion
        
        - preserveColor : pcr            (bool)          [create,query,edit]
            If true, boolean op will compute color for the new mesh. If false, the new mesh
            won't have any color set. Default:false
        
        - useThresholds : uth            (bool)          [create,query,edit]
            If true, merge vertices with separations less then vertexDistanceThreshold and
            collapse faces with areas less then faceAreaThreshold. If false, do not merge
            vertices or collapse faces Default:false
        
        - vertexDistanceThreshold : vdt  (float)         [create,query,edit]
            Tolerance to determine whether vertices (and edges) should be merged before
            boolean operation is applied. Attribute is ignored unless useThresholds is set
            to true Default:0.001                  Flags from polyCBoolOpFlags From
            polyUnite Node
        
        
        Derived from mel command `maya.cmds.polyBoolOp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Movie(File):
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbTorus(RevolvedPrimitive):
    def getAxis(self, **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getEndSweep(self, **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getHeightRatio(self, **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getMinorSweep(self, **kwargs):
        """
        The sweep angle for the minor circle in the torus Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getRadius(self, **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getSections(self, **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getSpans(self, **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getStartSweep(self, **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def getUseTolerance(self, **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setEndSweep(self, val='True', **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setHeightRatio(self, val='True', **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setMinorSweep(self, val='True', **kwargs):
        """
        The sweep angle for the minor circle in the torus Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setSections(self, val='True', **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setSpans(self, val='True', **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setStartSweep(self, val='True', **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    def setUseTolerance(self, val='True', **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The torus command creates a new torus and/or a dependency node that creates one,
        and returns their names.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            The primitive's axis
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface: 1 - linear, 3 - cubic Default:3
        
        - endSweep : esw                 (float)         [create,query,edit]
            The angle at which to end the surface of revolution. Default is 2Pi radians, or
            360 degrees. Default:6.2831853
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - heightRatio : hr               (float)         [create,query,edit]
            Ratio of heightto widthDefault:2.0
        
        - minorSweep : msw               (float)         [create,query,edit]
            The sweep angle for the minor circle in the torus Default:6.2831853
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - pivot : p                      (float, float, float) [create,query,edit]
            The primitive's pivot point
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        - radius : r                     (float)         [create,query,edit]
            The radius of the object Default:1.0
        
        - sections : s                   (int)           [create,query,edit]
            The number of sections determines the resolution of the surface in the sweep
            direction. Used only if useTolerance is false. Default:8
        
        - spans : nsp                    (int)           [create,query,edit]
            The number of spans determines the resolution of the surface in the opposite
            direction. Default:1
        
        - startSweep : ssw               (float)         [create,query,edit]
            The angle at which to start the surface of revolution Default:0
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to build the surface. Used only if useTolerance is true
            Default:0.01
        
        - useTolerance : ut              (bool)          [create,query,edit]
            Use the specified tolerance to determine resolution. Otherwise number of
            sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.torus`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'torus'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class VectorAdjust(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdPlanarProj(SubdModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbsBoolOverride(ApplyAbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbsStringOverride(ApplyAbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbs2FloatsOverride(ApplyAbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyRelIntOverride(ApplyRelOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolySphere(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the sphere. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getRadius(self, **kwargs):
        """
        This flag specifies the radius of the sphere. C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getSubdivisionsAxis(self, **kwargs):
        """
        Subdivisions around the axis.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height of the sphere.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getSubdivisionsX(self, **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the sphere. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def getSubdivisionsY(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the sphere. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the sphere. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        This flag specifies the radius of the sphere. C: Default is 0.5. Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setSubdivisionsAxis(self, val='True', **kwargs):
        """
        Subdivisions around the axis.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height of the sphere.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setSubdivisionsX(self, val='True', **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the sphere. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    def setSubdivisionsY(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the sphere. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The sphere command creates a new polygonal sphere.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the sphere. Q: When
            queried, this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create]
            This flag alows a specific UV mechanism to be selected, while creating the
            sphere. The valid values are 0, 1, or 2. 0 implies that no UVs will be generated
            (No texture to be applied). 1 implies UVs are created with pinched at poles 2
            implies UVs are created with sawtooth at poles For better understanding of these
            options, you may have to open the texture view windowC: Default is 2
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        - radius : r                     (float)         [create,query,edit]
            This flag specifies the radius of the sphere. C: Default is 0.5. Q: When
            queried, this flag returns a float.
        
        - subdivisionsAxis : sa          (int)           [create,query,edit]
            Subdivisions around the axis.
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height of the sphere.
        
        - subdivisionsX : sx             (int)           [create,query,edit]
            This specifies the number of subdivisions in the X direction for the sphere. C:
            Default is 20. Q: When queried, this flag returns an int.
        
        - subdivisionsY : sy             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Y direction for the
            sphere. C: Default is 20. Q: When queried, this flag returns an int.
        
        - texture : tx                   (int)           [create]
            This flag is obsolete and will be removed in the next release. The
            -cuv/createUVs flag should be used instead.                  Common poly
            creation operation flags
        
        
        Derived from mel command `maya.cmds.polySphere`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromSurfaceCoS(CurveFromSurface):
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbsEnumOverride(ApplyAbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NurbsTessellate(ParentTessellate):
    __melnode__ = []
    
    
    __readonly__ = {}


class ShellDeformer(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyRel3FloatsOverride(ApplyRelOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyExtrudeVertex(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def getDivisions(self, **kwargs):
        """
        This flag specifies the number of subdivisions. C: Default is 1 Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def getLength(self, **kwargs):
        """
        This flag specifies the length of the vertex extrusion. C: Default is 0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def getWidth(self, **kwargs):
        """
        This flag specifies the width of the vertex extrusion. C: Default is 0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def setDivisions(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions. C: Default is 1 Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def setLength(self, val='True', **kwargs):
        """
        This flag specifies the length of the vertex extrusion. C: Default is 0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        This flag specifies the width of the vertex extrusion. C: Default is 0 Q: When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command that extrudes selected vertices outwards.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - divisions : d                  (int)           [create,query,edit]
            This flag specifies the number of subdivisions. C: Default is 1 Q: When queried,
            this flag returns an int.
        
        - frozen : fzn                   (bool)          []
        
        - length : l                     (float)         [create,query,edit]
            This flag specifies the length of the vertex extrusion. C: Default is 0 Q: When
            queried, this flag returns a float.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - width : w                      (float)         [create,query,edit]
            This flag specifies the width of the vertex extrusion. C: Default is 0 Q: When
            queried, this flag returns a float.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyExtrudeVertex`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Shape(DagNode):
    def getTransform(self): pass
    def setParent(self, *args, **kwargs): pass
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbsFloatOverride(ApplyAbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCrease(PolyModifierWorld):
    def getCreateHistory(self, **kwargs):
        """
        For objects that have no construction history, this flag can be used to force the creation of construction history for creasing.  By default, history is not created if the object has no history.  Regardless of this flag, history is always created if the object already has history.                                  
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def getOperation(self, **kwargs):
        """
        Operation to perform.  Valid values are: 0: Crease the specified components. 1: Remove the crease values for the specified components. 2: Remove all crease values from the mesh. Default is 0.                                    
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def getRelativeValue(self, **kwargs):
        """
        Specifies a new relative value for all selected vertex and edge components. This flag can not be used at the same time as either the value or vertexValue flags.                                   
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def getValue(self, **kwargs):
        """
        Specifies the crease value for the selected edge components. When specified multiple times, the values are assigned respectively to the specified edges.                                   
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def getVertexValue(self, **kwargs):
        """
        Specifies the crease value for the selected vertex components. When specified multiple times, the values are assigned respectively to the specified vertices.                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def setCreateHistory(self, val='True', **kwargs):
        """
        For objects that have no construction history, this flag can be used to force the creation of construction history for creasing.  By default, history is not created if the object has no history.  Regardless of this flag, history is always created if the object already has history.                                  
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def setOperation(self, val='True', **kwargs):
        """
        Operation to perform.  Valid values are: 0: Crease the specified components. 1: Remove the crease values for the specified components. 2: Remove all crease values from the mesh. Default is 0.                                    
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def setRelativeValue(self, val='True', **kwargs):
        """
        Specifies a new relative value for all selected vertex and edge components. This flag can not be used at the same time as either the value or vertexValue flags.                                   
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Specifies the crease value for the selected edge components. When specified multiple times, the values are assigned respectively to the specified edges.                                   
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    def setVertexValue(self, val='True', **kwargs):
        """
        Specifies the crease value for the selected vertex components. When specified multiple times, the values are assigned respectively to the specified vertices.                              Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command to set the crease values on the edges or vertices of a poly.  The crease
        values are used by the smoothing algorithm.
        
        Flags:
        - createHistory : ch             (bool)          [create,query,edit]
            For objects that have no construction history, this flag can be used to force
            the creation of construction history for creasing.  By default, history is not
            created if the object has no history.  Regardless of this flag, history is
            always created if the object already has history.
        
        - operation : op                 (int)           [create,query,edit]
            Operation to perform.  Valid values are: 0: Crease the specified components. 1:
            Remove the crease values for the specified components. 2: Remove all crease
            values from the mesh. Default is 0.
        
        - relativeValue : rv             (float)         [create,query,edit]
            Specifies a new relative value for all selected vertex and edge components. This
            flag can not be used at the same time as either the value or vertexValue flags.
        
        - value : v                      (float)         [create,query,edit]
            Specifies the crease value for the selected edge components. When specified
            multiple times, the values are assigned respectively to the specified edges.
        
        - vertexValue : vv               (float)         [create,query,edit]
            Specifies the crease value for the selected vertex components. When specified
            multiple times, the values are assigned respectively to the specified vertices.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCrease`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MakeNurbSphere(RevolvedPrimitive):
    def getAxis(self, **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getDegree(self, **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getEndSweep(self, **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getHeightRatio(self, **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getRadius(self, **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getSections(self, **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getSpans(self, **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getStartSweep(self, **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getTolerance(self, **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def getUseTolerance(self, **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        The primitive's axis                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setDegree(self, val='True', **kwargs):
        """
        The degree of the resulting surface: 1 - linear, 3 - cubic Default:3                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setEndSweep(self, val='True', **kwargs):
        """
        The angle at which to end the surface of revolution. Default is 2Pi radians, or 360 degrees. Default:6.2831853                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setHeightRatio(self, val='True', **kwargs):
        """
        Ratio of heightto widthDefault:2.0                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The primitive's pivot point                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        The radius of the object Default:1.0                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setSections(self, val='True', **kwargs):
        """
        The number of sections determines the resolution of the surface in the sweep direction. Used only if useTolerance is false. Default:8                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setSpans(self, val='True', **kwargs):
        """
        The number of spans determines the resolution of the surface in the opposite direction. Default:1                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setStartSweep(self, val='True', **kwargs):
        """
        The angle at which to start the surface of revolution Default:0                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setTolerance(self, val='True', **kwargs):
        """
        The tolerance with which to build the surface. Used only if useTolerance is true Default:0.01                  
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    def setUseTolerance(self, val='True', **kwargs):
        """
        Use the specified tolerance to determine resolution. Otherwise number of sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The sphere command creates a new sphere. The number of spans in the in each
        direction of the sphere is determined by the useTolerance attribute. If -ut is
        true then the -tolerance attribute will be used. If -ut is false then the
        -sections attribute will be used.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            The primitive's axis
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - degree : d                     (int)           [create,query,edit]
            The degree of the resulting surface: 1 - linear, 3 - cubic Default:3
        
        - endSweep : esw                 (float)         [create,query,edit]
            The angle at which to end the surface of revolution. Default is 2Pi radians, or
            360 degrees. Default:6.2831853
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - heightRatio : hr               (float)         [create,query,edit]
            Ratio of heightto widthDefault:2.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - pivot : p                      (float, float, float) [create,query,edit]
            The primitive's pivot point
        
        - polygon : po                   (int)           [create]
            The value of this argument controls the type of the object created by this
            operation 0: nurbs surface1: polygon (use nurbsToPolygonsPref to set the
            parameters for the conversion)2: subdivision surface (use nurbsToSubdivPref to
            set the parameters for the conversion)3: Bezier surface4: subdivision surface
            solid (use nurbsToSubdivPref to set the parameters for the conversion)Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        - radius : r                     (float)         [create,query,edit]
            The radius of the object Default:1.0
        
        - sections : s                   (int)           [create,query,edit]
            The number of sections determines the resolution of the surface in the sweep
            direction. Used only if useTolerance is false. Default:8
        
        - spans : nsp                    (int)           [create,query,edit]
            The number of spans determines the resolution of the surface in the opposite
            direction. Default:1
        
        - startSweep : ssw               (float)         [create,query,edit]
            The angle at which to start the surface of revolution Default:0
        
        - tolerance : tol                (float)         [create,query,edit]
            The tolerance with which to build the surface. Used only if useTolerance is true
            Default:0.01
        
        - useTolerance : ut              (bool)          [create,query,edit]
            Use the specified tolerance to determine resolution. Otherwise number of
            sections will be used. Default:false                  Common flags
        
        
        Derived from mel command `maya.cmds.sphere`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'sphere'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyAbsIntOverride(ApplyAbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromSubdivEdge(CurveFromSubdiv):
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyRelFloatOverride(ApplyRelOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMergeVert(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleStretch(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleRelative(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Override(ChildNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Transform(DagNode):
    def __getattr__(self, attr):
        """
        Checks in the following order:
            1. Functions on this node class
            2. Attributes on this node class
            3. Functions on this node class's shape
            4. Attributes on this node class's shape
        """
        pass
    def __setattr__(self, attr, val):
        """
        Checks in the following order:
            1. Functions on this node class
            2. Attributes on this node class
            3. Functions on this node class's shape
            4. Attributes on this node class's shape
        """
        pass
    def attr(self, attr, checkShape='True'):
        """
        when checkShape is enabled, if the attribute does not exist the
        transform but does on the shape, then the shape's attribute will
        be returned.
        
        Returns
        -------
        general.Attribute
        """
        pass
    def centerPivots(self, val='True', **kwargs):
        """
        Set pivot points to the center of the object's bounding box. (see -p flag)                  
        
        - centerPivots : p               (bool)          [create]
            preserve overall transformation. used to prevent object from jumpingwhen
            changing pivots or rotation order. the default value is true. (used with -sp,
            -rp, -roo, -cp, -ra)
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def centerPivotsOnComponents(self, val='True', **kwargs):
        """
        Set pivot points to the center of the component's bounding box. (see -p flag)                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def clearRestPosition(self):
        """
        Clear the saved rest position of this transform.
        Derived from api method `maya.OpenMaya.MFnTransform.clearRestPosition`
        """
        pass
    def deletePriorHistory(self, val='True', **kwargs):
        """
        If true then delete the construction history before the operation is performed.                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def enableLimit(self, type, flag):
        """
        Enable or disable the limit value for the specified limit type.
        
        Parameters:
        type : 'Transform.LimitType'
            type to apply a limit
        
            values: 'scaleMinX', 'scaleMaxX', 'scaleMinY', 'scaleMaxY', 'scaleMinZ', 'scaleMaxZ', 'shearMinXY', 'shearMaxXY', 'shearMinXZ', 'shearMaxXZ', 'shearMinYZ', 'shearMaxYZ', 'rotateMinX', 'rotateMaxX', 'rotateMinY', 'rotateMaxY', 'rotateMinZ', 'rotateMaxZ', 'translateMinX', 'translateMaxX', 'translateMinY', 'translateMaxY', 'translateMinZ', 'translateMaxZ'
        flag : 'bool'
            true or false to enable
        
        Derived from api method `maya.OpenMaya.MFnTransform.enableLimit`
        
        Aliases: enableLimit, setLimited
        """
        pass
    def getBoundingBox(self, invisible='False', space="'object'"):
        """
        xform -boundingBox and xform -boundingBoxInvisible
        
        Returns
        -------
        datatypes.BoundingBox
        """
        pass
    def getBoundingBoxInvisible(self, **kwargs):
        """
        Returns the bounding box of an object. This includes the bounding boxes of all invisible children which are not included using the boundingBox flag. The values returned are in following order: xmin ymin zmin xmax ymax zmax.                  
        
        - boundingBoxInvisible : os      (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - boundingBoxInvisible : ws      (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def getBoundingBoxMax(self, invisible='False', space="'object'"):
        """
        Returns
        -------
        datatypes.Vector
        """
        pass
    def getBoundingBoxMin(self, invisible='False', space="'object'"):
        """
        Returns
        -------
        datatypes.Vector
        """
        pass
    def getLimit(self, type):
        """
        Determine the current value of the specified limit.
        
        Parameters:
        type : 'Transform.LimitType'
            type to query limit
        
            values: 'scaleMinX', 'scaleMaxX', 'scaleMinY', 'scaleMaxY', 'scaleMinZ', 'scaleMaxZ', 'shearMinXY', 'shearMaxXY', 'shearMinXZ', 'shearMaxXZ', 'shearMinYZ', 'shearMaxYZ', 'rotateMinX', 'rotateMaxX', 'rotateMinY', 'rotateMaxY', 'rotateMinZ', 'rotateMaxZ', 'translateMinX', 'translateMaxX', 'translateMinY', 'translateMaxY', 'translateMinZ', 'translateMaxZ'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnTransform.limitValue`
        
        Aliases: getLimit, limitValue
        """
        pass
    def getMatrix(self, **kwargs):
        """
        Sets/returns the composite transformation matrix. \*Note\* the matrix is represented by 16 double arguments that are specified in row order.                  
        
        - matrix : os                    (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - matrix : ws                    (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def getPivots(self, **kwargs):
        """
        convenience method that changes both the rotate and scale pivots simultaneously. (see -rp -sp flags for more info)                  
        
        - pivots : os                    (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - pivots : ws                    (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        - pivots : wd                    (bool)          [create,query]
            Values for -sp, -rp, -st, -rt, -t, -piv flags are treated as world space
            distances to move along the local axis. (where the local axis depends on whether
            the command is operating in local-space or object-space. This flag has no effect
            for world space.
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def getRestPosition(self):
        """
        Retrieve the saved rest position of this transform.
        
        Returns:
        'TransformationMatrix'
        
        Derived from api method `maya.OpenMaya.MFnTransform.restPosition`
        """
        pass
    def getRotateAxis(self, **kwargs):
        """
        rotation axis orientation (when used with the -p flag the overall rotation is preserved by modifying the rotation to compensate for the axis rotation)                  
        
        - rotateAxis : os                (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - rotateAxis : ws                (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        - rotateAxis : p                 (bool)          [create]
            preserve overall transformation. used to prevent object from jumpingwhen
            changing pivots or rotation order. the default value is true. (used with -sp,
            -rp, -roo, -cp, -ra)
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def getRotateOrientation(self, space="'transform'"):
        """
        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.
        
        Parameters:
        space : 'Space.Space'
            space in which to get the rotation orientation. This argument is currently ignored. The rotateOrientation is always returned in local space: MSpace::kTransform.
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Quaternion'
        
        Derived from api method `maya.OpenMaya.MSpace.rotateOrientation`
        """
        pass
    def getRotatePivot(self, space="'object'", **kwargs):
        """
        Returns the pivot about which the rotation is applied.
        
        Parameters:
        space : 'Space.Space'
            space in which to get the pivot
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.rotatePivot`
        """
        pass
    def getRotatePivotTranslation(self, space="'object'", **kwargs):
        """
        Return the rotate pivot translation in linear units. 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.
        
        Parameters:
        space : 'Space.Space'
            space in which to get the pivot translation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.rotatePivotTranslation`
        """
        pass
    def getRotation(self, space="'object'", quaternion='False', **kwargs):
        """
            Modifications:
              - added 'quaternion' keyword arg, to specify whether the result
                be returned as a Quaternion object, as opposed to the default
                EulerRotation object
              - added 'space' keyword arg, which defaults to 'object'
                
        Retrieve the rotation component of this transformation. The rotation is retrieved in MSpace::kTransform space.
        
        Returns:
        'EulerRotation'
        
        Derived from api method `maya.OpenMaya.MFnTransform.getRotation`
        """
        pass
    def getRotationOrder(self):
        """
        Returns the rotation order for the transform matrix - the order in which the Euler angles are applied to create the end rotation.
        
        Returns:
        'TransformationMatrix.RotationOrder'
        
        Derived from api method `maya.OpenMaya.MFnTransform.rotationOrder`
        """
        pass
    def getScale(self):
        """
        Retrieve the scaling component of this transformation.
        
        Returns:
        ('float', 'float', 'float')
        
        Derived from api method `maya.OpenMaya.MFnTransform.getScale`
        """
        pass
    def getScalePivot(self, space="'object'", **kwargs):
        """
        Returns the pivot around which the scale is applied. The pivot will be in linear units.
        
        Parameters:
        space : 'Space.Space'
            space in which to get the pivot
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.scalePivot`
        """
        pass
    def getScalePivotTranslation(self, space="'object'", **kwargs):
        """
        Returns the scale pivot translation in linear units. 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.
        
        Parameters:
        space : 'Space.Space'
            space in which to get the scale pivot translation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.scalePivotTranslation`
        """
        pass
    def getShape(self, **kwargs):
        """
        Returns
        -------
        DagNode
        """
        pass
    def getShapes(self, **kwargs):
        """
        Returns
        -------
        List[DagNode]
        """
        pass
    def getShear(self):
        """
        Retrieve the shearing component of this transformation.
        
        Returns:
        ('float', 'float', 'float')
        
        Derived from api method `maya.OpenMaya.MFnTransform.getShear`
        """
        pass
    def getTransformation(self):
        """
        Retrieve the transformation matrix represented by this transform.
        
        Returns:
        'TransformationMatrix'
        
        Derived from api method `maya.OpenMaya.MFnTransform.transformation`
        
        Aliases: getTransformation, transformation
        """
        pass
    def getTranslation(self, space="'object'", **kwargs):
        """
        Retrieve the translation component of this transformation in linear units.
        
        Parameters:
        space : 'Space.Space'
            transform space in which to get the translation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.getTranslation`
        """
        pass
    def isLimited(self, type):
        """
        Determine if the specified limit attribute is enabled or disabled.
        
        Parameters:
        type : 'Transform.LimitType'
            type to query limit
        
            values: 'scaleMinX', 'scaleMaxX', 'scaleMinY', 'scaleMaxY', 'scaleMinZ', 'scaleMaxZ', 'shearMinXY', 'shearMaxXY', 'shearMinXZ', 'shearMaxXZ', 'shearMinYZ', 'shearMaxYZ', 'rotateMinX', 'rotateMaxX', 'rotateMinY', 'rotateMaxY', 'rotateMinZ', 'rotateMaxZ', 'translateMinX', 'translateMaxX', 'translateMinY', 'translateMaxY', 'translateMinZ', 'translateMaxZ'
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnTransform.isLimited`
        """
        pass
    def limitValue(self, type):
        """
        Determine the current value of the specified limit.
        
        Parameters:
        type : 'Transform.LimitType'
            type to query limit
        
            values: 'scaleMinX', 'scaleMaxX', 'scaleMinY', 'scaleMaxY', 'scaleMinZ', 'scaleMaxZ', 'shearMinXY', 'shearMaxXY', 'shearMinXZ', 'shearMaxXZ', 'shearMinYZ', 'shearMaxYZ', 'rotateMinX', 'rotateMaxX', 'rotateMinY', 'rotateMaxY', 'rotateMinZ', 'rotateMaxZ', 'translateMinX', 'translateMaxX', 'translateMinY', 'translateMaxY', 'translateMinZ', 'translateMaxZ'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnTransform.limitValue`
        
        Aliases: getLimit, limitValue
        """
        pass
    def preserveUV(self, val='True', **kwargs):
        """
        When true, UV values on rotated components are projected across the rotation in 3d space. For small edits, this will freeze the world space texture mapping on the object. When false, the UV values will not change for a selected vertices. Default is false.                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def reflection(self, val='True', **kwargs):
        """
        To move the corresponding symmetric components also.                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def reflectionAboutBBox(self, val='True', **kwargs):
        """
        Sets the position of the reflection axis  at the geometry bounding box                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def reflectionAboutOrigin(self, val='True', **kwargs):
        """
        Sets the position of the reflection axis  at the origin                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def reflectionAboutX(self, val='True', **kwargs):
        """
        Specifies the X=0 as reflection plane                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def reflectionAboutY(self, val='True', **kwargs):
        """
        Specifies the Y=0 as reflection plane                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def reflectionAboutZ(self, val='True', **kwargs):
        """
        Specifies the Z=0 as reflection plane                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def reflectionTolerance(self, val='True', **kwargs):
        """
        Specifies the tolerance to findout the corresponding reflected components                  
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def resetFromRestPosition(self):
        """
        Reset the transform to its rest position.
        Derived from api method `maya.OpenMaya.MFnTransform.resetFromRestPosition`
        """
        pass
    def rotateBy(self, rotation, space="'object'", **kwargs):
        """
                Modifications:
                  - rotation may be a Quaternion or MQuaternion
                
        Relatively change the rotation of this transformation using a quaternion.
        
        Parameters:
        quaternion : 'Quaternion'
            the quaternion
        space : 'Space.Space'
            transform space in which to perform the rotation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.rotateBy`
        """
        pass
    def rotateByQuaternion(self, xOrQuaternion, y='None', z='None', w='None', space="'transform'"):
        """
                Modifications:
                  - may feed in a single Quaternion object/list/tuple instead of 4 separate floats
                
        Relatively change the rotation of this transformation using a quaternion.
        
        Parameters:
        x : 'float'
            x component of the quaternion
        y : 'float'
            y component of the quaternion
        z : 'float'
            z component of the quaternion
        w : 'float'
            w component of the quaternion
        space : 'Space.Space'
            transform space in which to perform the rotation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.rotateByQuaternion`
        """
        pass
    def scaleBy(self, scale, **kwargs):
        """
        Relatively scale this transformation.
        
        Parameters:
        scale : ('float', 'float', 'float')
            The ratio by which to scale the transform
        
        Derived from api method `maya.OpenMaya.MFnTransform.scaleBy`
        """
        pass
    def set(self, transform):
        """
        Change this transform to equal the given matrix.
        
        Parameters:
        transform : 'TransformationMatrix'
            the matrix to copy
        
        Derived from api method `maya.OpenMaya.MFnTransform.set`
        
        Aliases: set, setTransformation
        """
        pass
    def setLimit(self, type, value):
        """
        Change the limit value for the specified limit type, and automatically enable the limit to be true.
        
        Parameters:
        type : 'Transform.LimitType'
            type to apply a limit
        
            values: 'scaleMinX', 'scaleMaxX', 'scaleMinY', 'scaleMaxY', 'scaleMinZ', 'scaleMaxZ', 'shearMinXY', 'shearMaxXY', 'shearMinXZ', 'shearMaxXZ', 'shearMinYZ', 'shearMaxYZ', 'rotateMinX', 'rotateMaxX', 'rotateMinY', 'rotateMaxY', 'rotateMinZ', 'rotateMaxZ', 'translateMinX', 'translateMaxX', 'translateMinY', 'translateMaxY', 'translateMinZ', 'translateMaxZ'
        value : 'float'
            new limit value as internal unit
        
        Derived from api method `maya.OpenMaya.MFnTransform.setLimit`
        """
        pass
    def setLimited(self, type, flag):
        """
        Enable or disable the limit value for the specified limit type.
        
        Parameters:
        type : 'Transform.LimitType'
            type to apply a limit
        
            values: 'scaleMinX', 'scaleMaxX', 'scaleMinY', 'scaleMaxY', 'scaleMinZ', 'scaleMaxZ', 'shearMinXY', 'shearMaxXY', 'shearMinXZ', 'shearMaxXZ', 'shearMinYZ', 'shearMaxYZ', 'rotateMinX', 'rotateMaxX', 'rotateMinY', 'rotateMaxY', 'rotateMinZ', 'rotateMaxZ', 'translateMinX', 'translateMaxX', 'translateMinY', 'translateMaxY', 'translateMinZ', 'translateMaxZ'
        flag : 'bool'
            true or false to enable
        
        Derived from api method `maya.OpenMaya.MFnTransform.enableLimit`
        
        Aliases: enableLimit, setLimited
        """
        pass
    def setMatrix(self, val, **kwargs):
        """
        rotation axis orientation (when used with the -p flag the overall rotation is preserved by modifying the rotation to compensate for the axis rotation)                  
        
        - rotateAxis : os                (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - rotateAxis : ws                (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        - rotateAxis : p                 (bool)          [create]
            preserve overall transformation. used to prevent object from jumpingwhen
            changing pivots or rotation order. the default value is true. (used with -sp,
            -rp, -roo, -cp, -ra)
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def setPivots(self, val='True', **kwargs):
        """
        convenience method that changes both the rotate and scale pivots simultaneously. (see -rp -sp flags for more info)                  
        
        - pivots : os                    (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - pivots : ws                    (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        - pivots : wd                    (bool)          [create,query]
            Values for -sp, -rp, -st, -rt, -t, -piv flags are treated as world space
            distances to move along the local axis. (where the local axis depends on whether
            the command is operating in local-space or object-space. This flag has no effect
            for world space.
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def setRestPosition(self, matrix):
        """
        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.
        
        Parameters:
        matrix : 'TransformationMatrix'
            the new rest position for this transform
        
        Derived from api method `maya.OpenMaya.MFnTransform.setRestPosition`
        """
        pass
    def setRotateAxis(self, val='True', **kwargs):
        """
        rotation axis orientation (when used with the -p flag the overall rotation is preserved by modifying the rotation to compensate for the axis rotation)                  
        
        - rotateAxis : os                (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - rotateAxis : ws                (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        - rotateAxis : p                 (bool)          [create]
            preserve overall transformation. used to prevent object from jumpingwhen
            changing pivots or rotation order. the default value is true. (used with -sp,
            -rp, -roo, -cp, -ra)
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    def setRotateOrientation(self, quat, space="'transform'", balance='True'):
        """
        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.
        
        Parameters:
        quat : 'Quaternion'
            new orientation as a quaternion
        space : 'Space.Space'
            transform space in which to set the rotateOrientation. This argument is currently ignored. The rotateOrientation always set in local space: MSpace::kTransform.
        
            values: 'transform', 'preTransform', 'object', 'world'
        balance : 'bool'
            whether to balance the overall transformation matrix
        
        Derived from api method `maya.OpenMaya.MSpace.setRotateOrientation`
        """
        pass
    def setRotatePivot(self, point, space="'object'", balance='True', **kwargs):
        """
        Set the rotate pivot in linear units about which rotation is applied.
        
        Parameters:
        point : 'Point'
            new rotation pivot in centimeters
        space : 'Space.Space'
            transform space in which to set the pivot
        
            values: 'transform', 'preTransform', 'object', 'world'
        balance : 'bool'
            whether to balance the matrix
        
        Derived from api method `maya.OpenMaya.MSpace.setRotatePivot`
        """
        pass
    def setRotatePivotTranslation(self, vector, space="'object'", **kwargs):
        """
        Set the rotate pivot translation in linear units. 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.
        
        Parameters:
        vector : 'Vector'
            new rotation pivot translation in centimeters
        space : 'Space.Space'
            transform space in which to set the rotation pivot translation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setRotatePivotTranslation`
        """
        pass
    def setRotation(self, rotation, space="'object'", **kwargs):
        """
            Modifications:
              - rotation may be given as an EulerRotation, Quaternion, or iterable of 3
                or 4 components (to specify an euler/quaternion, respectively)
                
        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.
        
        Parameters:
        quaternion : 'Quaternion'
            the quaternion
        space : 'Space.Space'
            transform space in which to perform the rotation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setRotation`
        """
        pass
    def setRotationOrder(self, order, reorder):
        """
        Change the rotation order for the transform - the order in which the Euler angles are applied to create the end rotation.
        
        Parameters:
        order : 'TransformationMatrix.RotationOrder'
            the order in which to apply rotations
        
            values: 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX'
        reorder : 'bool'
            flag indicating whether or not rotations should be reordered.
        
        Derived from api method `maya.OpenMaya.MTransformationMatrix.setRotationOrder`
        """
        pass
    def setScale(self, scale, **kwargs):
        """
        Set the scaling component of this transformation.
        
        Parameters:
        scale : ('float', 'float', 'float')
            The scale of the transform
        
        Derived from api method `maya.OpenMaya.MFnTransform.setScale`
        """
        pass
    def setScalePivot(self, point, space="'object'", balance='True', **kwargs):
        """
        Set the pivot around which the scale is applied in linear units.
        
        Parameters:
        point : 'Point'
            new scale pivot in centimeters
        space : 'Space.Space'
            transform space in which to set the scale pivot
        
            values: 'transform', 'preTransform', 'object', 'world'
        balance : 'bool'
            whether to balance the matrix
        
        Derived from api method `maya.OpenMaya.MSpace.setScalePivot`
        """
        pass
    def setScalePivotTranslation(self, vector, space="'object'", **kwargs):
        """
        Set the scale pivot translation in linear units. 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.
        
        Parameters:
        vector : 'Vector'
            new scale pivot translation in centimeters
        space : 'Space.Space'
            transform space in which to set the scale translation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setScalePivotTranslation`
        """
        pass
    def setShear(self, shear, **kwargs):
        """
        Set the shearing component of this transformation.
        
        Parameters:
        shear : ('float', 'float', 'float')
            The shear of the transform
        
        Derived from api method `maya.OpenMaya.MFnTransform.setShear`
        """
        pass
    def setTransformation(self, transform):
        """
        Change this transform to equal the given matrix.
        
        Parameters:
        transform : 'TransformationMatrix'
            the matrix to copy
        
        Derived from api method `maya.OpenMaya.MFnTransform.set`
        
        Aliases: set, setTransformation
        """
        pass
    def setTranslation(self, vector, space="'object'", **kwargs):
        """
        Change the translation component of this transformation.
        
        Parameters:
        vector : 'Vector'
            the new translation vector in centimeters
        space : 'Space.Space'
            transform space in which to perform the translation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setTranslation`
        """
        pass
    def shearBy(self, shear, **kwargs):
        """
        Relatively shear this transformation.
        
        Parameters:
        shear : ('float', 'float', 'float')
            The ratio by which to shear the transform
        
        Derived from api method `maya.OpenMaya.MFnTransform.shearBy`
        """
        pass
    def transformation(self):
        """
        Retrieve the transformation matrix represented by this transform.
        
        Returns:
        'TransformationMatrix'
        
        Derived from api method `maya.OpenMaya.MFnTransform.transformation`
        
        Aliases: getTransformation, transformation
        """
        pass
    def translateBy(self, vector, space="'object'", **kwargs):
        """
        Relatively change the translation component of this transformation.
        
        Parameters:
        vector : 'Vector'
            the relative translation vector
        space : 'Space.Space'
            transform space in which to perform the translation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.translateBy`
        """
        pass
    def ungroup(self, **kwargs): pass
    def zeroTransformPivots(self, val='True', **kwargs):
        """
        reset pivot points and pivot translations without changing the overall matrix by applying these values into the translation channel.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command can be used query/set any element in a transformation node. It can
        also be used to query some values that cannot be set directly such as the
        transformation matrix or the bounding box. It can also set both pivot points to
        convenient values. All values are specified in transformation coordinates.
        (attribute-space) In addition, the attributes are applied/returned in the order
        in which they appear in the flags section. (which corresponds to the order they
        appear in the transformation matrix as given below) See also:move, rotate, scale
        where: [sp] = |  1      0        0       0 | = scale pivot matrix |  0      1
        0       0 | |  0      0        1       0 | | -spx   -spy     -spz     1 | [s]  =
        |  sx     0        0       0 | = scale matrix |  0      sy       0       0 | |
        0      0        sz      0 | |  0      0        0       1 | [sh] = |  1      0
        0       0 | = shear matrix |  xy     1        0       0 | |  xz     yz       1
        0 | |  0      0        0       1 | -1 [sp] = |  1       0       0       0 | =
        scale pivot inverse matrix |  0       1       0       0 | |  0       0       1
        0 | |  spx     spy     spz     1 | [st] = |  1       0       0       0 | = scale
        translate matrix |  0       1       0       0 | |  0       0       1       0 | |
        stx     sty     stz     1 | [rp] = |  1       0       0       0 | = rotate pivot
        matrix |  0       1       0       0 | |  0       0       1       0 | | -rpx
        -rpy    -rpz     1 | [ar] = |  \*       \*       \*       0 | = axis rotation
        matrix |  \*       \*       \*       0 |   (composite rotation, |  \*       \*
        \*       0 |    see [rx], [ry], [rz] |  0       0       0       1 |    below for
        details) [rx] = |  1       0       0       0 | = rotate X matrix |  0
        cos(x)  sin(x)  0 | |  0      -sin(x)  cos(x)  0 | |  0       0       0       1
        | [ry] = |  cos(y)  0      -sin(y)  0 | = rotate Y matrix |  0       1       0
        0 | |  sin(y)  0       cos(y)  0 | |  0       0       0       1 | [rz] = |
        cos(z)  sin(z)  0       0 | = rotate Z matrix | -sin(z)  cos(z)  0       0 | |
        0       0       1       0 | |  0       0       0       1 | -1 [rp] = |  1
        0       0       0 | = rotate pivot matrix |  0       1       0       0 | |  0
        0       1       0 | |  rpx     rpy     rpz     1 | [rt] = |  1       0       0
        0 | = rotate translate matrix |  0       1       0       0 | |  0       0
        1       0 | |  rtx     rty     rtz     1 | [t]  = |  1       0       0       0 |
        = translation matrix |  0       1       0       0 | |  0       0       1       0
        | |  tx      ty      tz      1 | In query mode, return type is based on queried
        flag.
        
        Flags:
        - absolute : a                   (bool)          [create]
            perform absolute transformation (default)
        
        - boundingBox : bb               (bool)          [query]
            Returns the bounding box of an object. The values returned are in the following
            order: xmin ymin zmin xmax ymax zmax.
        
        - boundingBoxInvisible : bbi     (bool)          [query]
            Returns the bounding box of an object. This includes the bounding boxes of all
            invisible children which are not included using the boundingBox flag. The values
            returned are in following order: xmin ymin zmin xmax ymax zmax.
        
        - centerPivots : cp              (bool)          [create]
            Set pivot points to the center of the object's bounding box. (see -p flag)
        
        - centerPivotsOnComponents : cpc (bool)          [create]
            Set pivot points to the center of the component's bounding box. (see -p flag)
        
        - deletePriorHistory : dph       (bool)          [create]
            If true then delete the construction history before the operation is performed.
        
        - euler : eu                     (bool)          [create]
            modifer for -relative flag that specifies rotation values should be added to
            current XYZ rotation values.
        
        - matrix : m                     (float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float) [create,query]
            Sets/returns the composite transformation matrix. \*Note\* the matrix is
            represented by 16 double arguments that are specified in row order.
        
        - objectSpace : os               (bool)          [create,query]
            treat values as object-space transformation values (only works for pivots,
            translations, rotation, rotation axis, matrix, and bounding box flags)
        
        - pivots : piv                   (float, float, float) [create,query]
            convenience method that changes both the rotate and scale pivots simultaneously.
            (see -rp -sp flags for more info)
        
        - preserve : p                   (bool)          [create]
            preserve overall transformation. used to prevent object from jumpingwhen
            changing pivots or rotation order. the default value is true. (used with -sp,
            -rp, -roo, -cp, -ra)
        
        - preserveUV : puv               (bool)          [create]
            When true, UV values on rotated components are projected across the rotation in
            3d space. For small edits, this will freeze the world space texture mapping on
            the object. When false, the UV values will not change for a selected vertices.
            Default is false.
        
        - reflection : rfl               (bool)          [create]
            To move the corresponding symmetric components also.
        
        - reflectionAboutBBox : rab      (bool)          [create]
            Sets the position of the reflection axis  at the geometry bounding box
        
        - reflectionAboutOrigin : rao    (bool)          [create]
            Sets the position of the reflection axis  at the origin
        
        - reflectionAboutX : rax         (bool)          [create]
            Specifies the X=0 as reflection plane
        
        - reflectionAboutY : ray         (bool)          [create]
            Specifies the Y=0 as reflection plane
        
        - reflectionAboutZ : raz         (bool)          [create]
            Specifies the Z=0 as reflection plane
        
        - reflectionTolerance : rft      (float)         [create]
            Specifies the tolerance to findout the corresponding reflected components
        
        - relative : r                   (bool)          [create]
            perform relative transformation
        
        - rotateAxis : ra                (float, float, float) [create,query]
            rotation axis orientation (when used with the -p flag the overall rotation is
            preserved by modifying the rotation to compensate for the axis rotation)
        
        - rotateOrder : roo              (unicode)       [create,query]
            rotation order (when used with the -p flag the overall rotation is preserved by
            modifying the local rotation to be quivalent to the old one) Valid values for
            this flag are xyz | yzx | zxy | xzy | yxz | zyx
        
        - rotatePivot : rp               (float, float, float) [create,query]
            rotate pivot point transformation (when used with the -p flag the overall
            transformation is preserved by modifying the rotation translation)
        
        - rotateTranslation : rt         (float, float, float) [create,query]
            rotation translation
        
        - rotation : ro                  (float, float, float) [create,query]
            rotation transformation
        
        - scale : s                      (float, float, float) [create,query]
            scale transformation
        
        - scalePivot : sp                (float, float, float) [create,query]
            scale pivot point transformation (when used with the -p flag the overall
            transformation is preserved by modifying the scale translation)
        
        - scaleTranslation : st          (float, float, float) [create,query]
            scale translation
        
        - shear : sh                     (float, float, float) [create,query]
            shear transformation. The values represent the shear xy,xz,yz
        
        - translation : t                (float, float, float) [create,query]
            translation
        
        - worldSpace : ws                (bool)          [create,query]
            (works for pivots, translations, rotation, rotation axis, matrix, and bounding
            box flags). Note that, when querying the scale, that this calculation is
            cumulative and is only valid if there are all uniform scales and no rotation. In
            a hierarchy with non-uniform scale and rotation, this value may not correspond
            entirely with the perceived global scale.
        
        - worldSpaceDistance : wd        (bool)          [create,query]
            Values for -sp, -rp, -st, -rt, -t, -piv flags are treated as world space
            distances to move along the local axis. (where the local axis depends on whether
            the command is operating in local-space or object-space. This flag has no effect
            for world space.
        
        - zeroTransformPivots : ztp      (bool)          [create]
            reset pivot points and pivot translations without changing the overall matrix by
            applying these values into the translation channel.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.xform`
        """
        pass
    LimitType = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = True
    
    
    __melcmdname__ = 'xform'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ApplyRel2FloatsOverride(ApplyRelOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCut(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneCenter(self, **kwargs):
        """
        The position of the cutting plane. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneCenterX(self, **kwargs):
        """
        Cutting plane center X coord.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneCenterY(self, **kwargs):
        """
        Cutting plane center Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneCenterZ(self, **kwargs):
        """
        Cutting plane center Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneHeight(self, **kwargs):
        """
        The height of the cutting plane                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneRotate(self, **kwargs):
        """
        The orientation of the cutting plane. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneRotateX(self, **kwargs):
        """
        cutting plane X rotate angle.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneRotateY(self, **kwargs):
        """
        cutting plane Y rotate angle.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneRotateZ(self, **kwargs):
        """
        cutting plane Z rotate angle.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneSize(self, **kwargs):
        """
        The width and the height of the cutting plane Default:1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getCutPlaneWidth(self, **kwargs):
        """
        The width of the cutting plane                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getDeleteFaces(self, **kwargs):
        """
        whether to delete the one-half of the cut-faces of the poly.  If true, they are deleted. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getExtractFaces(self, **kwargs):
        """
        whether to extract the cut-faces of the poly into a separate shell.  If true, they are extracted. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getExtractOffset(self, **kwargs):
        """
        The displacement offset of the cut faces. Default:0.5, 0.5, 0.5                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getExtractOffsetX(self, **kwargs):
        """
        The X-displacement offset of the cut faces.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getExtractOffsetY(self, **kwargs):
        """
        The Y-displacement offset of the cut faces.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getExtractOffsetZ(self, **kwargs):
        """
        The Z-displacement offset of the cut faces.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getOnObject(self, **kwargs):
        """
        whether to act on the entire polyObject or its selected face components Default:true                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneCenter(self, val='True', **kwargs):
        """
        The position of the cutting plane. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneCenterX(self, val='True', **kwargs):
        """
        Cutting plane center X coord.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneCenterY(self, val='True', **kwargs):
        """
        Cutting plane center Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneCenterZ(self, val='True', **kwargs):
        """
        Cutting plane center Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneHeight(self, val='True', **kwargs):
        """
        The height of the cutting plane                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneRotate(self, val='True', **kwargs):
        """
        The orientation of the cutting plane. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneRotateX(self, val='True', **kwargs):
        """
        cutting plane X rotate angle.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneRotateY(self, val='True', **kwargs):
        """
        cutting plane Y rotate angle.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneRotateZ(self, val='True', **kwargs):
        """
        cutting plane Z rotate angle.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneSize(self, val='True', **kwargs):
        """
        The width and the height of the cutting plane Default:1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setCutPlaneWidth(self, val='True', **kwargs):
        """
        The width of the cutting plane                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setDeleteFaces(self, val='True', **kwargs):
        """
        whether to delete the one-half of the cut-faces of the poly.  If true, they are deleted. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setExtractFaces(self, val='True', **kwargs):
        """
        whether to extract the cut-faces of the poly into a separate shell.  If true, they are extracted. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setExtractOffset(self, val='True', **kwargs):
        """
        The displacement offset of the cut faces. Default:0.5, 0.5, 0.5                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setExtractOffsetX(self, val='True', **kwargs):
        """
        The X-displacement offset of the cut faces.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setExtractOffsetY(self, val='True', **kwargs):
        """
        The Y-displacement offset of the cut faces.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setExtractOffsetZ(self, val='True', **kwargs):
        """
        The Z-displacement offset of the cut faces.                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setOnObject(self, val='True', **kwargs):
        """
        whether to act on the entire polyObject or its selected face components Default:true                  
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command splits a mesh, or a set of poly faces, along a plane. The position
        and orientation of the plane can be adjusted using the appropriate flags listed
        above.  In addition, the cut operation can also delete the faces lying on one
        side of the cutting plane, or extract those faces by an offset amount.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - cutPlaneCenter : pc            (float, float, float) [create,query,edit]
            The position of the cutting plane. Default:0.0, 0.0, 0.0
        
        - cutPlaneCenterX : pcx          (float)         [create,query,edit]
            Cutting plane center X coord.
        
        - cutPlaneCenterY : pcy          (float)         [create,query,edit]
            Cutting plane center Y coord.
        
        - cutPlaneCenterZ : pcz          (float)         [create,query,edit]
            Cutting plane center Z coord.
        
        - cutPlaneHeight : ph            (float)         [create,query,edit]
            The height of the cutting plane
        
        - cutPlaneRotate : ro            (float, float, float) [create,query,edit]
            The orientation of the cutting plane. Default:0.0, 0.0, 0.0
        
        - cutPlaneRotateX : rx           (float)         [create,query,edit]
            cutting plane X rotate angle.
        
        - cutPlaneRotateY : ry           (float)         [create,query,edit]
            cutting plane Y rotate angle.
        
        - cutPlaneRotateZ : rz           (float)         [create,query,edit]
            cutting plane Z rotate angle.
        
        - cutPlaneSize : ps              (float, float)  [create,query,edit]
            The width and the height of the cutting plane Default:1.0, 1.0
        
        - cutPlaneWidth : pw             (float)         [create,query,edit]
            The width of the cutting plane
        
        - cuttingDirection : cd          (unicode)       [create]
            This flag specifies the direction of the cutting plane. Valid values are x, y,
            zA value of xwill cut the object along the YZ plane cutting through the center
            of the bounding box. A value of ywill cut the object along the ZX plane cutting
            through the center of the bounding box. A value of zwill cut the object along
            the XY plane cutting through the center of the bounding box.
        
        - deleteFaces : df               (bool)          [create,query,edit]
            whether to delete the one-half of the cut-faces of the poly.  If true, they are
            deleted. Default:false
        
        - extractFaces : ef              (bool)          [create,query,edit]
            whether to extract the cut-faces of the poly into a separate shell.  If true,
            they are extracted. Default:false
        
        - extractOffset : eo             (float, float, float) [create,query,edit]
            The displacement offset of the cut faces. Default:0.5, 0.5, 0.5
        
        - extractOffsetX : eox           (float)         [create,query,edit]
            The X-displacement offset of the cut faces.
        
        - extractOffsetY : eoy           (float)         [create,query,edit]
            The Y-displacement offset of the cut faces.
        
        - extractOffsetZ : eoz           (float)         [create,query,edit]
            The Z-displacement offset of the cut faces.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - onObject : oo                  (bool)          [create,query,edit]
            whether to act on the entire polyObject or its selected face components
            Default:true
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCut`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyAverageVertex(PolyModifierWorld):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def getIterations(self, **kwargs):
        """
        Number of rounding steps.                  
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def setIterations(self, val='True', **kwargs):
        """
        Number of rounding steps.                  
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Moves the selected vertices of a polygonal object to round its shape. Translate,
        move, rotate or scale vertices.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - iterations : i                 (int)           [create,query,edit]
            Number of rounding steps.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyAverageVertex`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Jiggle(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Blinn(Reflect):
    def getEccentricity(self):
        """
        Retrieves the value of the "eccentricity" attribute of a blinn shader node. This attribute determines the size of the highlight produced by the shader.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnBlinnShader.eccentricity`
        """
        pass
    def getSpecularRollOff(self):
        """
        Retrieves the value of the "specularRollOff" attribute of a blinn shader node. This attribute controls the increased oblique angle reflectivity of the shader.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnBlinnShader.specularRollOff`
        """
        pass
    def setEccentricity(self, eccentr):
        """
        Sets the value of the "eccentricity" attribute of a shader node.
        
        Parameters:
        eccentr : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnBlinnShader.setEccentricity`
        """
        pass
    def setSpecularRollOff(self, specular_rolloff):
        """
        Sets the value of the "specularRollOff" attribute of a shader node.
        
        Parameters:
        specular_rolloff : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnBlinnShader.setSpecularRollOff`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleSplineDeformer(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class LightItemBase(ChildNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCylProj(PolyModifierWorld):
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_ShellDeformer(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCylinder(PolyPrimitive):
    def getAxis(self, **kwargs):
        """
        This flag specifies the primitive axis used to build the cylinder. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getCreateUVs(self, **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getFrozen(self, **kwargs):
        """
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the cylinder. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getRadius(self, **kwargs):
        """
        Radius of the cylinder. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getRoundCap(self, **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getSubdivisionsAxis(self, **kwargs):
        """
        Subdivisions around the axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getSubdivisionsCaps(self, **kwargs):
        """
        Subdivisions on the caps Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getSubdivisionsHeight(self, **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getSubdivisionsX(self, **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the cylinder. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getSubdivisionsY(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the cylinder. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getSubdivisionsZ(self, **kwargs):
        """
        This flag specifies the number of subdivisions in the Z direction for the cylinder. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def getTexture(self, **kwargs):
        """
        What texture mechanism to be applied 0=No textures, 1=Object, 2=Faces Default:2                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setAxis(self, val='True', **kwargs):
        """
        This flag specifies the primitive axis used to build the cylinder. Q: When queried, this flag returns a float[3].                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setCreateUVs(self, val='True', **kwargs):
        """
        Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and Preserve Aspect RatioDefault:2                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setFrozen(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the cylinder. Default:2.0                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        Radius of the cylinder. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setRoundCap(self, val='True', **kwargs):
        """
        To indicate whether we need a round cap Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setSubdivisionsAxis(self, val='True', **kwargs):
        """
        Subdivisions around the axis. Default:20                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setSubdivisionsCaps(self, val='True', **kwargs):
        """
        Subdivisions on the caps Default:0                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setSubdivisionsHeight(self, val='True', **kwargs):
        """
        Subdivisions along the height. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setSubdivisionsX(self, val='True', **kwargs):
        """
        This specifies the number of subdivisions in the X direction for the cylinder. C: Default is 20. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setSubdivisionsY(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Y direction for the cylinder. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setSubdivisionsZ(self, val='True', **kwargs):
        """
        This flag specifies the number of subdivisions in the Z direction for the cylinder. C: Default is 1. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    def setTexture(self, val='True', **kwargs):
        """
        What texture mechanism to be applied 0=No textures, 1=Object, 2=Faces Default:2                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The cylinder command creates a new polygonal cylinder.
        
        Flags:
        - axis : ax                      (float, float, float) [create,query,edit]
            This flag specifies the primitive axis used to build the cylinder. Q: When
            queried, this flag returns a float[3].
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createUVs : cuv                (int)           [create,query,edit]
            Create UVs or not. 0: No UVs1: No Normalization2: Normalize3: Normalize and
            Preserve Aspect RatioDefault:2
        
        - frozen : fzn                   (bool)          [query,edit]
        
        - height : h                     (float)         [create,query,edit]
            Height of the cylinder. Default:2.0
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node (where applicable).
        
        - radius : r                     (float)         [create,query,edit]
            Radius of the cylinder. Default:1.0
        
        - roundCap : rcp                 (bool)          [create,query,edit]
            To indicate whether we need a round cap Default:false
        
        - subdivisionsAxis : sa          (int)           [create,query,edit]
            Subdivisions around the axis. Default:20
        
        - subdivisionsCaps : sc          (int)           [create,query,edit]
            Subdivisions on the caps Default:0
        
        - subdivisionsHeight : sh        (int)           [create,query,edit]
            Subdivisions along the height. Default:1
        
        - subdivisionsX : sx             (int)           [create,query,edit]
            This specifies the number of subdivisions in the X direction for the cylinder.
            C: Default is 20. Q: When queried, this flag returns an int.
        
        - subdivisionsY : sy             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Y direction for the
            cylinder. C: Default is 1. Q: When queried, this flag returns an int.
        
        - subdivisionsZ : sz             (int)           [create,query,edit]
            This flag specifies the number of subdivisions in the Z direction for the
            cylinder. C: Default is 1. Q: When queried, this flag returns an int.
        
        - texture : tx                   (int)           [create,query,edit]
            What texture mechanism to be applied 0=No textures, 1=Object, 2=Faces Default:2
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCylinder`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyBevel3(PolyModifierWorld):
    def getAngleTolerance(self, **kwargs):
        """
        Angular tolerance for creation of extra triangles Note this attribute is for compatability only and should not be modified in Maya 7.0 files Default:20.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getAutoFit(self, **kwargs):
        """
        If autoFit is on, it computes a smooth roundness :  new facets round off a smooth angle. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getChamfer(self, **kwargs):
        """
        If chamfer is on, the surface is smoothed out at bevels. When it is off, the shape of the surface remains the same. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getDepth(self, **kwargs):
        """
        The depth of bevel. One means a smooth surface, -1 means maximum depth. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getFillNgons(self, **kwargs):
        """
        Subdivide new faces with more than 4 edges Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getMergeVertexTolerance(self, **kwargs):
        """
        Tolerance within which to merge vertices Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getMergeVertices(self, **kwargs):
        """
        Merge vertices within a tolerance Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getMiterAlong(self, **kwargs):
        """
        Controls in which direction new vertices should we offseted. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getMitering(self, **kwargs):
        """
        Controls how the topology should look like at corners. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getMiteringAngle(self, **kwargs):
        """
        Miter faces that have angles less than this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getOffset(self, **kwargs):
        """
        The offset for bevel. Default:0.2                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getOffsetAsFraction(self, **kwargs):
        """
        If on, the offset value is treated as a fraction between zero and one. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getRoundness(self, **kwargs):
        """
        The roundness of bevel, it is taken into account when autoFit is off. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getSegments(self, **kwargs):
        """
        The number of segments used for beveling. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getSmoothingAngle(self, **kwargs):
        """
        Create new edges as hard edges if the angle between adjacent faces exceeds this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getUvAssignment(self, **kwargs):
        """
        Technique used to compute UVs on new faces 0 computes new UVs by projecting along surface normal of original mesh onto new mesh 1 computes new UVs by projecting along surface normal of new mesh onto original mesh Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setAngleTolerance(self, val='True', **kwargs):
        """
        Angular tolerance for creation of extra triangles Note this attribute is for compatability only and should not be modified in Maya 7.0 files Default:20.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setAutoFit(self, val='True', **kwargs):
        """
        If autoFit is on, it computes a smooth roundness :  new facets round off a smooth angle. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setChamfer(self, val='True', **kwargs):
        """
        If chamfer is on, the surface is smoothed out at bevels. When it is off, the shape of the surface remains the same. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setDepth(self, val='True', **kwargs):
        """
        The depth of bevel. One means a smooth surface, -1 means maximum depth. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setFillNgons(self, val='True', **kwargs):
        """
        Subdivide new faces with more than 4 edges Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setMergeVertexTolerance(self, val='True', **kwargs):
        """
        Tolerance within which to merge vertices Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setMergeVertices(self, val='True', **kwargs):
        """
        Merge vertices within a tolerance Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setMiterAlong(self, val='True', **kwargs):
        """
        Controls in which direction new vertices should we offseted. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setMitering(self, val='True', **kwargs):
        """
        Controls how the topology should look like at corners. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setMiteringAngle(self, val='True', **kwargs):
        """
        Miter faces that have angles less than this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        The offset for bevel. Default:0.2                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setOffsetAsFraction(self, val='True', **kwargs):
        """
        If on, the offset value is treated as a fraction between zero and one. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setRoundness(self, val='True', **kwargs):
        """
        The roundness of bevel, it is taken into account when autoFit is off. Default:0.5                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setSegments(self, val='True', **kwargs):
        """
        The number of segments used for beveling. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setSmoothingAngle(self, val='True', **kwargs):
        """
        Create new edges as hard edges if the angle between adjacent faces exceeds this value Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setUvAssignment(self, val='True', **kwargs):
        """
        Technique used to compute UVs on new faces 0 computes new UVs by projecting along surface normal of original mesh onto new mesh 1 computes new UVs by projecting along surface normal of new mesh onto original mesh Default:0                  
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Bevel edges.
        
        Flags:
        - angleTolerance : at            (float)         [create,query,edit]
            Angular tolerance for creation of extra triangles Note this attribute is for
            compatability only and should not be modified in Maya 7.0 files Default:20.0
        
        - autoFit : af                   (bool)          [create,query,edit]
            If autoFit is on, it computes a smooth roundness :  new facets round off a
            smooth angle. Default:true
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - chamfer : c                    (bool)          [create,query,edit]
            If chamfer is on, the surface is smoothed out at bevels. When it is off, the
            shape of the surface remains the same. Default:true
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - depth : d                      (float)         [create,query,edit]
            The depth of bevel. One means a smooth surface, -1 means maximum depth.
            Default:1.0
        
        - fillNgons : fn                 (bool)          [create,query,edit]
            Subdivide new faces with more than 4 edges Default:false
        
        - forceParallel : fp             (bool)          []
        
        - fraction : f                   (float)         []
        
        - frozen : fzn                   (bool)          []
        
        - maya2015 : m15                 (bool)          []
        
        - maya2016SP3 : m16              (bool)          []
        
        - maya2017Update1 : m17          (bool)          []
        
        - mergeVertexTolerance : mvt     (float)         [create,query,edit]
            Tolerance within which to merge vertices Default:0.0
        
        - mergeVertices : mv             (bool)          [create,query,edit]
            Merge vertices within a tolerance Default:false
        
        - miterAlong : mia               (int)           [create,query,edit]
            Controls in which direction new vertices should we offseted. Default:0
        
        - mitering : m                   (int)           [create,query,edit]
            Controls how the topology should look like at corners. Default:0
        
        - miteringAngle : ma             (float)         [create,query,edit]
            Miter faces that have angles less than this value Default:0.0
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - offset : o                     (float)         [create,query,edit]
            The offset for bevel. Default:0.2
        
        - offsetAsFraction : oaf         (bool)          [create,query,edit]
            If on, the offset value is treated as a fraction between zero and one.
            Default:false
        
        - roundness : r                  (float)         [create,query,edit]
            The roundness of bevel, it is taken into account when autoFit is off.
            Default:0.5
        
        - segments : sg                  (int)           [create,query,edit]
            The number of segments used for beveling. Default:1
        
        - smoothingAngle : sa            (float)         [create,query,edit]
            Create new edges as hard edges if the angle between adjacent faces exceeds this
            value Default:0.0
        
        - subdivideNgons : sn            (bool)          []
        
        - uvAssignment : ua              (int)           [create,query,edit]
            Technique used to compute UVs on new faces 0 computes new UVs by projecting
            along surface normal of original mesh onto new mesh 1 computes new UVs by
            projecting along surface normal of new mesh onto original mesh Default:0
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyBevel3`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleMultiCollide(THdeformer):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveFromSubdivFace(CurveFromSubdiv):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCreaseEdge(PolyCrease):
    __melnode__ = []
    
    
    __readonly__ = {}


class DynBase(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DynHolder(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class HikEffector(Transform):
    def getAuxiliaryEffectors(self):
        """
        Returns an array of the auxiliary effectors associated with this effector. Auxiliary effectors are used by humanIK to act as additional pivots.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMayaAnim.MFnHikEffector.getAuxiliaryEffectors`
        """
        pass
    def getEffColor(self):
        """
        Retrieve the cached humanIK color of this effector.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMayaAnim.MFnHikEffector.getEffColor`
        """
        pass
    def getPivotOffset(self):
        """
        Retrieve the pivot offset of this effector.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaAnim.MFnHikEffector.getPivotOffset`
        """
        pass
    def setEffColor(self, color):
        """
        Set the humanIK color for this effector.
        
        Parameters:
        color : 'Color'
            the new color
        
        Derived from api method `maya.OpenMayaAnim.MFnHikEffector.setEffColor`
        """
        pass
    def setPivotOffset(self, vector):
        """
        Set the pivot offset for this effector.
        
        Parameters:
        vector : 'Vector'
            the new pivot offset
        
        Derived from api method `maya.OpenMayaAnim.MFnHikEffector.setPivotOffset`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DynamicConstraint(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyBevel2(PolyBevel):
    __melnode__ = []
    
    
    __readonly__ = {}


class Nucleus(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class UnknownTransform(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class TextureBakeSet(BakeSet):
    __melnode__ = []
    
    
    __readonly__ = {}


class RigidConstraint(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class LightItem(LightItemBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class VertexBakeSet(BakeSet):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyLayoutUV(PolyModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getFlipReversed(self, **kwargs):
        """
        If this flag is turned on, the reversed UV pieces are fliped.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getLayout(self, **kwargs):
        """
        How to move the UV pieces, after cuts are applied: 0 No move is applied. 1 Layout the pieces along the U axis. 2 Layout the pieces in a square shape.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getLayoutMethod(self, **kwargs):
        """
        Which layout method to use: 0 Block Stacking. 1 Shape Stacking.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getPercentageSpace(self, **kwargs):
        """
        When layout is set to square, this value is a percentage of the texture area which is added around each UV piece. It can be used to ensure each UV piece uses different pixels in the texture. Maximum value is 5 percent.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getRotateForBestFit(self, **kwargs):
        """
        0 No rotation is applied. 1 Only allow 90 degree rotations. 2 Allow free rotations.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getScale(self, **kwargs):
        """
        How to scale the pieces, after move and cuts: 0 No scale is applied. 1 Uniform scale to fit in unit square. 2 Non proportional scale to fit in unit square.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getSeparate(self, **kwargs):
        """
        Which UV edges should be cut: 0 No cuts. 1 Cut only along folds. 2 Make all necessary cuts to avoid all intersections.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setFlipReversed(self, val='True', **kwargs):
        """
        If this flag is turned on, the reversed UV pieces are fliped.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setLayout(self, val='True', **kwargs):
        """
        How to move the UV pieces, after cuts are applied: 0 No move is applied. 1 Layout the pieces along the U axis. 2 Layout the pieces in a square shape.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setLayoutMethod(self, val='True', **kwargs):
        """
        Which layout method to use: 0 Block Stacking. 1 Shape Stacking.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setPercentageSpace(self, val='True', **kwargs):
        """
        When layout is set to square, this value is a percentage of the texture area which is added around each UV piece. It can be used to ensure each UV piece uses different pixels in the texture. Maximum value is 5 percent.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setRotateForBestFit(self, val='True', **kwargs):
        """
        0 No rotation is applied. 1 Only allow 90 degree rotations. 2 Allow free rotations.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        How to scale the pieces, after move and cuts: 0 No scale is applied. 1 Uniform scale to fit in unit square. 2 Non proportional scale to fit in unit square.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setSeparate(self, val='True', **kwargs):
        """
        Which UV edges should be cut: 0 No cuts. 1 Cut only along folds. 2 Make all necessary cuts to avoid all intersections.                  
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Move UVs in the texture plane to avoid overlaps.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - flipReversed : fr              (bool)          [create,query,edit]
            If this flag is turned on, the reversed UV pieces are fliped.
        
        - frozen : fzn                   (bool)          []
        
        - gridU : gu                     (int)           []
        
        - gridV : gv                     (int)           []
        
        - layout : l                     (int)           [create,query,edit]
            How to move the UV pieces, after cuts are applied: 0 No move is applied. 1
            Layout the pieces along the U axis. 2 Layout the pieces in a square shape.
        
        - layoutMethod : lm              (int)           [create,query,edit]
            Which layout method to use: 0 Block Stacking. 1 Shape Stacking.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - percentageSpace : ps           (float)         [create,query,edit]
            When layout is set to square, this value is a percentage of the texture area
            which is added around each UV piece. It can be used to ensure each UV piece uses
            different pixels in the texture. Maximum value is 5 percent.
        
        - rotateForBestFit : rbf         (int)           [create,query,edit]
            0 No rotation is applied. 1 Only allow 90 degree rotations. 2 Allow free
            rotations.
        
        - scale : sc                     (int)           [create,query,edit]
            How to scale the pieces, after move and cuts: 0 No scale is applied. 1 Uniform
            scale to fit in unit square. 2 Non proportional scale to fit in unit square.
        
        - separate : se                  (int)           [create,query,edit]
            Which UV edges should be cut: 0 No cuts. 1 Cut only along folds. 2 Make all
            necessary cuts to avoid all intersections.
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyLayoutUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Waiter(THobjectSet):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyPinUV(PolyModifierUV):
    def getCreateHistory(self, **kwargs):
        """
        For objects that have no construction history, this flag can be used to force the creation of construction history for pinning.  By default, history is not created if the object has no history.  Regardless of this flag, history is always created if the object already has history.                                   
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def getOperation(self, **kwargs):
        """
        Operation to perform.  Valid values are: 0: Set pin weights on the selected UVs. 1: Set pin weights to zero for the selected UVs. 2: Remove pin weights from the entire mesh. 3: Invert pin weights of the entire mesh. Default is 0.                              
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def getUnpinned(self, **kwargs):
        """
        List all selected UVs which are not pinned.                                
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def getUvSetName(self, **kwargs):
        """
        Specifies the name of the UV set to edit UVs on. If not specified the current UV set will be used if it exists.                                    
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def getValue(self, **kwargs):
        """
        Specifies the pin value for the selected UV components. When specified multiple times, the values are assigned respectively to the specified UVs.                                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def setCreateHistory(self, val='True', **kwargs):
        """
        For objects that have no construction history, this flag can be used to force the creation of construction history for pinning.  By default, history is not created if the object has no history.  Regardless of this flag, history is always created if the object already has history.                                   
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def setOperation(self, val='True', **kwargs):
        """
        Operation to perform.  Valid values are: 0: Set pin weights on the selected UVs. 1: Set pin weights to zero for the selected UVs. 2: Remove pin weights from the entire mesh. 3: Invert pin weights of the entire mesh. Default is 0.                              
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def setUnpinned(self, val='True', **kwargs):
        """
        List all selected UVs which are not pinned.                                
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def setUvSetName(self, val='True', **kwargs):
        """
        Specifies the name of the UV set to edit UVs on. If not specified the current UV set will be used if it exists.                                    
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Specifies the pin value for the selected UV components. When specified multiple times, the values are assigned respectively to the specified UVs.                                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to pin and unpin UVs. A pinnedUV is one which should not be
        modified.  Each UV has an associated pin weight, that defaults to 0.0 meaning
        that the UV is not pinned. If pin weight is set to 1.0 then it becomes fully
        pinned and UV tools should not modify that UV. If the pin weight is set to a
        value between 0.0 and 1.0 then UV tools should weight their changes to that UV
        accordingly.  UV pinning is not enforced by the shape node: it is up to each
        tool to decide whether it will obey the pin weights.
        
        Flags:
        - createHistory : ch             (bool)          [create,query,edit]
            For objects that have no construction history, this flag can be used to force
            the creation of construction history for pinning.  By default, history is not
            created if the object has no history.  Regardless of this flag, history is
            always created if the object already has history.
        
        - operation : op                 (int)           [create,query,edit]
            Operation to perform.  Valid values are: 0: Set pin weights on the selected UVs.
            1: Set pin weights to zero for the selected UVs. 2: Remove pin weights from the
            entire mesh. 3: Invert pin weights of the entire mesh. Default is 0.
        
        - unpinned : unp                 (bool)          [query,edit]
            List all selected UVs which are not pinned.
        
        - uvSetName : uvs                (unicode)       [create,query,edit]
            Specifies the name of the UV set to edit UVs on. If not specified the current UV
            set will be used if it exists.
        
        - value : v                      (float)         [create,query,edit]
            Specifies the pin value for the selected UV components. When specified multiple
            times, the values are assigned respectively to the specified UVs.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyPinUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyAutoProj(PolyModifierUV):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMapSewMove(PolyModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def getLimitPieceSize(self, **kwargs):
        """
        When on, this flag specifies that the face number limit described above should be used.                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def getNumberFaces(self, **kwargs):
        """
        Maximum number of faces in a UV piece. When trying to combine two UV pieces into a single one, the merge operation is rejected if the smaller piece has more faces than the number specified by this flag.This flag is only used when limitPieceSizeis set to on.                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def setLimitPieceSize(self, val='True', **kwargs):
        """
        When on, this flag specifies that the face number limit described above should be used.                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def setNumberFaces(self, val='True', **kwargs):
        """
        Maximum number of faces in a UV piece. When trying to combine two UV pieces into a single one, the merge operation is rejected if the smaller piece has more faces than the number specified by this flag.This flag is only used when limitPieceSizeis set to on.                  
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command can be used to Move and Sew together separate UV pieces along
        geometric edges. UV pieces that correspond to the same geometric edge, are
        merged together by moving the smaller piece to the larger one.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - limitPieceSize : lps           (bool)          [create,query,edit]
            When on, this flag specifies that the face number limit described above should
            be used.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - numberFaces : nf               (int)           [create,query,edit]
            Maximum number of faces in a UV piece. When trying to combine two UV pieces into
            a single one, the merge operation is rejected if the smaller piece has more
            faces than the number specified by this flag.This flag is only used when
            limitPieceSizeis set to on.
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMapSewMove`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyOptUvs(PolyModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Optimizes selected UVs.
        
        Flags:
        - applyToShell : applyToShell    (bool)          [create]
            Specifies where the whole object or just shells that are selected or pinned
            should be affected.
        
        - areaWeight : aw                (float)         [create]
            Surface driven importance. 0 treat all faces equal. 1 gives more importance to
            large ones.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - globalBlend : gb               (float)         [create]
            This allows the user to blend between a local optimization method (globalBlend =
            0.0) and a global optimization method (globalBlend = 1.0). The local
            optimization method looks at the ratio between the triangles on the object and
            the triangles in UV space.  It has a side affect that it can sometimes introduce
            tapering problems.  The global optimization is much slower, but takes into
            consideration the entire object when optimizing uv placement.
        
        - globalMethodBlend : gmb        (float)         [create]
            The global optimization method uses two functions to compute a minimization.
            The first function controls edge stretch by using edges lengths between xyz and
            uv.  The second function penalizes the first function by preventing
            configurations where triangles would overlap.  For every surface there is a mix
            between these two functions that will give the appropriate response. Values
            closer to 1.0 give more weight to the edge length function. Values closer to 0.0
            give more weight to surface area.  The default value of '0.5' is a even mix
            between these two values.
        
        - iterations : i                 (int)           [create]
            Maximum number of iterations for each connected UV piece.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - optimizeAxis : oa              (int)           [create]
            Degree of freedom for optimization: 0=Optimize freely, 1=Move vertically only,
            2=Move horzontally only
        
        - pinSelected : ps               (bool)          [create]
            Specifies that the selected components should be pinned instead of the
            unselected components.
        
        - pinUvBorder : pub              (bool)          [create]
            Specifies that the UV border should be pinned when doing the solve. By default
            only unselected components are pinned.
        
        - scale : s                      (float)         [create]
            Ratio between 2d and 3d space.
        
        - stoppingThreshold : ss         (float)         [create]
            Minimum distorsion improvement between two steps in %.
        
        - useScale : us                  (bool)          [create]
            Adjust the scale or not.
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyOptUvs`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HikGroundPlane(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class BaseGeometryVarGroup(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyStraightenUVBorder(PolyModifierUV):
    def getBlendOriginal(self, **kwargs):
        """
        Interpolation factor between the target and original UV shape. When the value is 0, the UVs will exactly fit the target curve. When the value is 1, no UV move.                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def getCurvature(self, **kwargs):
        """
        How curved the UV path will be. 0 is a straight line. When the values is 1, the mid point of the curve will be moved away from a straight line by 1/2 the length of the UV segment.                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def getGapTolerance(self, **kwargs):
        """
        When non 0, Small gaps between UV selection are filled. The integer number represent how many UVs must be traversed to connect togeterh selected pieces.                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def getPreserveLength(self, **kwargs):
        """
        How much we want to respect the UV edge ratios. When the value is 1, we build new UV position along the desired curve, respecting the original UV spacings. When the value is 0, new UVs are equally spaced along the curve.                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Move border UVs along a simple curve.
        
        Flags:
        - blendOriginal : bo             (float)         [create,query]
            Interpolation factor between the target and original UV shape. When the value is
            0, the UVs will exactly fit the target curve. When the value is 1, no UV move.
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - curvature : c                  (float)         [create,query]
            How curved the UV path will be. 0 is a straight line. When the values is 1, the
            mid point of the curve will be moved away from a straight line by 1/2 the length
            of the UV segment.
        
        - frozen : fzn                   (bool)          []
        
        - gapTolerance : gt              (int)           [create,query]
            When non 0, Small gaps between UV selection are filled. The integer number
            represent how many UVs must be traversed to connect togeterh selected pieces.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - preserveLength : pl            (float)         [create,query]
            How much we want to respect the UV edge ratios. When the value is 1, we build
            new UV position along the desired curve, respecting the original UV spacings.
            When the value is 0, new UVs are equally spaced along the curve.
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyStraightenUVBorder`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Place3dTexture(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class IkHandle(Transform):
    def autoPriority(self, val='True', **kwargs):
        """
        Specifies that this handle's priority is assigned automatically.  The assigned priority will be based on the hierarchy distance from the root of the skeletal chain to the start joint of the handle.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def connectEffector(self, val='True', **kwargs):
        """
        This option is set to true as default, meaning that end-effector translate is connected with the endJoint translate.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def disableHandles(self, val='True', **kwargs):
        """
        set given handles to full fk (ikBlend attribute = 0.0)                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def enableHandles(self, val='True', **kwargs):
        """
        set given handles to full ik (ikBlend attribute = 1.0)                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def freezeJoints(self, val='True', **kwargs):
        """
        Forces the curve, specfied by -curve option, to align itself along the existing joint chain. When false, or unspecified, the joints will be moved to positions along the specified curve.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getCurve(self, **kwargs):
        """
        Specifies the curve to be used by the ikSplineHandle. Joints will be moved to align with this curve. This flag is mandatory if you use the -freezeJoints option.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getEffector(self):
        """
        Get a dag path to the end-effector of the handle's joint chain.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.getEffector`
        """
        pass
    def getEndEffector(self, **kwargs):
        """
        Specifies the end-effector of the handle's joint chain. The end effector may be specified with a joint or an end-effector.  If a joint is specified, an end-effector will be created at the same position as the joint and this new end-effector will be used as the end-effector.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getForceSolver(self, **kwargs):
        """
        Forces the solver to be used everytime. It could also be known as animSticky. So, after you set the first key the handle is sticky.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getJointList(self, **kwargs):
        """
        Returns the list of joints that the handle is manipulating.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getPositionWeight(self, **kwargs):
        """
        Specifies the position/orientation weight of a handle. This is used to compute the distancebetween the goal position and the end-effector position.  A positionWeight of 1.0 computes the distance as the distance between positions only and ignores the orientations.  A positionWeight of 0.0 computes the distance as the distance between the orientations only and ignores the positions.  A positionWeight of 0.5 attempts to weight the distances equally but cannot actually compute this due to unit differences. Because there is no way to add linear units and angular units.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getPriority(self):
        """
        Get the priority of this handle in case a solution is affected by more than one handle.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.priority`
        """
        pass
    def getRootOnCurve(self, **kwargs):
        """
        Specifies if the root is locked onto the curve of the ikSplineHandle.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getRootTwistMode(self, **kwargs):
        """
        Specifies whether the start joint is allowed to twist or not. If not, then the required twist is distributed over the remaining joints. This applies to all the twist types.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getSnapHandleFlagToggle(self, **kwargs):
        """
        Specifies that the handle position should be snapped to the end-effector position if the end-effector is moved by the user.  Setting this flag on allows you to use forward kinematics to pose or adjust your skeleton and then to animate it with inverse kinematics.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getSolver(self):
        """
        Returns the solver attached to this handle.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.solver`
        """
        pass
    def getStartJoint(self):
        """
        This method will get a dag path to the starting joint of the handle's joint chain.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.getStartJoint`
        """
        pass
    def getStickiness(self):
        """
        Get the stickiness of this handle.
        
        Returns:
        'IkHandle.Stickiness'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.stickiness`
        """
        pass
    def getSticky(self, **kwargs):
        """
        Specifies that this handle is sticky. Valid values are off, sticky, superSticky. Sticky handles are solved when the skeleton is being manipulated interactively.  If a character has sticky feet, the solver will attempt to keep them in the same position as the user moves the character's root.  If they were not sticky, they would move along with the root.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getTwistType(self, **kwargs):
        """
        Specifies the type of interpolation to be used by the ikSplineHandle.  The interpolation options are linear, easeIn, easeOut, and easeInOut.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def getWeight(self):
        """
        Get the handles weight in error calculations. The weight only applies when handle goals are in conflict and cannot be solved simultaneously. When this happens, a solution is computed that weights the "distance" from each goal to the solution by the handle's weight and attempts to minimize this value. The weight must be >= 0.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.weight`
        """
        pass
    def poWeight(self):
        """
        Gets the position/orientation weight of a handle. This is used to compute the "distance" between the goal position and the end-effector position.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.poWeight`
        """
        pass
    def setCurve(self, val='True', **kwargs):
        """
        Specifies the curve to be used by the ikSplineHandle. Joints will be moved to align with this curve. This flag is mandatory if you use the -freezeJoints option.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setEffector(self, effectorPath):
        """
        Set the dag path to the end-effector of the handle's joint chain. The end-effector/joint must be on the same skeletal chain as the start joint or this method will fail.
        
        Parameters:
        effectorPath : 'PyNode'
            The path for the effector
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setEffector`
        """
        pass
    def setEndEffector(self, val='True', **kwargs):
        """
        Specifies the end-effector of the handle's joint chain. The end effector may be specified with a joint or an end-effector.  If a joint is specified, an end-effector will be created at the same position as the joint and this new end-effector will be used as the end-effector.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setForceSolver(self, val='True', **kwargs):
        """
        Forces the solver to be used everytime. It could also be known as animSticky. So, after you set the first key the handle is sticky.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setPOWeight(self, poWeight):
        """
        Sets the position/orientation weight of a handle. This is used to compute the "distance" between the goal position and the end-effector position.
        
        Parameters:
        poWeight : 'float'
            The position/orientation weight to be set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setPOWeight`
        """
        pass
    def setPositionWeight(self, val='True', **kwargs):
        """
        Specifies the position/orientation weight of a handle. This is used to compute the distancebetween the goal position and the end-effector position.  A positionWeight of 1.0 computes the distance as the distance between positions only and ignores the orientations.  A positionWeight of 0.0 computes the distance as the distance between the orientations only and ignores the positions.  A positionWeight of 0.5 attempts to weight the distances equally but cannot actually compute this due to unit differences. Because there is no way to add linear units and angular units.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setPriority(self, priority):
        """
        Set the priority of this handle in case a solution is affected by more than one handle
        
        Parameters:
        priority : 'int'
            The priority to set for this handle
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setPriority`
        """
        pass
    def setRootOnCurve(self, val='True', **kwargs):
        """
        Specifies if the root is locked onto the curve of the ikSplineHandle.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setRootTwistMode(self, val='True', **kwargs):
        """
        Specifies whether the start joint is allowed to twist or not. If not, then the required twist is distributed over the remaining joints. This applies to all the twist types.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setSnapHandleFlagToggle(self, val='True', **kwargs):
        """
        Specifies that the handle position should be snapped to the end-effector position if the end-effector is moved by the user.  Setting this flag on allows you to use forward kinematics to pose or adjust your skeleton and then to animate it with inverse kinematics.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setSolver(self, solver):
        """
        Set the solver for this handle.
        
        Parameters:
        solver : 'PyNode'
            The solver for this handle
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setSolver`
        """
        pass
    def setStartJoint(self, jointPath):
        """
        This method will set the dag path for the starting joint of the handle's joint chain. The start joint must be on the same skeletal chain as the end effector or this method will fail.
        
        Parameters:
        jointPath : 'PyNode'
            The dag path to the joint that will be set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setStartJoint`
        """
        pass
    def setStartJointAndEffector(self, jointPath, effectorPath):
        """
        This method will set the dag path for the starting joint and the end-effector of the handle's joint chain. This method must be used when setting the joints for a handle that are in a different skeletal chain then the current one.
        
        Parameters:
        jointPath : 'PyNode'
            The dag path to the joint that will be set
        effectorPath : 'PyNode'
            The path for the effector
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setStartJointAndEffector`
        """
        pass
    def setStickiness(self, stickiness):
        """
        Set the stickiness of this handle. Sticky handles are solved when the skeleton is being manipulated interactively. If a character has sticky feet, the solver will attempt to keep them in the same position as the user moves the character's root. If they were not sticky, they would move along with the root.
        
        Parameters:
        stickiness : 'IkHandle.Stickiness'
            The stickiness value to be set.
        
            values: 'stickyOff', 'stickyOn', 'superSticky'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setStickiness`
        """
        pass
    def setSticky(self, val='True', **kwargs):
        """
        Specifies that this handle is sticky. Valid values are off, sticky, superSticky. Sticky handles are solved when the skeleton is being manipulated interactively.  If a character has sticky feet, the solver will attempt to keep them in the same position as the user moves the character's root.  If they were not sticky, they would move along with the root.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setTwistType(self, val='True', **kwargs):
        """
        Specifies the type of interpolation to be used by the ikSplineHandle.  The interpolation options are linear, easeIn, easeOut, and easeInOut.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def setWeight(self, weight):
        """
        Specifies the handles weight in error calculations. The weight only applies when handle goals are in conflict and cannot be solved simultaneously. When this happens, a solution is computed that weights the "distance" from each goal to the solution by the handle's weight and attempts to minimize this value. The weight must be >= 0.
        
        Parameters:
        weight : 'float'
            The weight value to be set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkHandle.setWeight`
        """
        pass
    def setupForRPsolver(self, val='True', **kwargs):
        """
        If the flag is set and ikSolver is ikRPsolver, call RPRotateSetup for the new ikHandle. It is for ikRPsolver only.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    def snapHandleToEffector(self, val='True', **kwargs):
        """
        All handles are immediately moved so that the handle position and orientation matches the end-effector position and orientation.                  
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The handle command is used to create, edit, and query a handle within Maya.  The
        standard edit (-e) and query (-q) flags are used for edit and query functions.
        If there are 2 joints selected and neither -startJoint nor -endEffector flags
        are not specified, then the handle will be created from the selected joints. If
        a single joint is selected and neither -startJoint nor -endEffector flags are
        specified, then the handle will be created with the selected joint as the end-
        effector and the start joint will be the top of the joint chain containing the
        end effector. The default values of the flags are: -name ikHandle#-priority
        1-weight 1.0-positionWeight 1.0-solver ikRPsolver-forceSolver on-
        snapHandleFlagToggle on-sticky off-createCurve true-simplifyCurve true-
        rootOnCurve true-twistType linear-createRootAxis false-parentCurve true-
        snapCurve false-numSpans 1-rootTwistMode false.These attributes can be specified
        in creation mode, edited in edit mode (-e) or queried in query mode (-q).
        
        Flags:
        - autoPriority : ap              (bool)          [edit]
            Specifies that this handle's priority is assigned automatically.  The assigned
            priority will be based on the hierarchy distance from the root of the skeletal
            chain to the start joint of the handle.
        
        - connectEffector : ce           (bool)          [create,edit]
            This option is set to true as default, meaning that end-effector translate is
            connected with the endJoint translate.
        
        - createCurve : ccv              (bool)          [create]
            Specifies if a curve should automatically be created for the ikSplineHandle.
        
        - createRootAxis : cra           (bool)          [create]
            Specifies if a root transform should automatically be created above the joints
            affected by the ikSplineHandle. This option is used to prevent the root flipping
            singularity on a motion path.
        
        - curve : c                      (PyNode)        [create,query,edit]
            Specifies the curve to be used by the ikSplineHandle. Joints will be moved to
            align with this curve. This flag is mandatory if you use the -freezeJoints
            option.
        
        - disableHandles : dh            (bool)          [edit]
            set given handles to full fk (ikBlend attribute = 0.0)
        
        - enableHandles : eh             (bool)          [edit]
            set given handles to full ik (ikBlend attribute = 1.0)
        
        - endEffector : ee               (unicode)       [create,query,edit]
            Specifies the end-effector of the handle's joint chain. The end effector may be
            specified with a joint or an end-effector.  If a joint is specified, an end-
            effector will be created at the same position as the joint and this new end-
            effector will be used as the end-effector.
        
        - exists : ex                    (unicode)       [edit]
            Indicates if the specified handle exists or not.
        
        - forceSolver : fs               (bool)          [create,query,edit]
            Forces the solver to be used everytime. It could also be known as animSticky.
            So, after you set the first key the handle is sticky.
        
        - freezeJoints : fj              (bool)          [create,edit]
            Forces the curve, specfied by -curve option, to align itself along the existing
            joint chain. When false, or unspecified, the joints will be moved to positions
            along the specified curve.
        
        - jointList : jl                 (bool)          [query]
            Returns the list of joints that the handle is manipulating.
        
        - name : n                       (unicode)       [create,query,edit]
            Specifies the name of the handle.
        
        - numSpans : ns                  (int)           [create]
            Specifies the number of spans in the automatically generated curve of the
            ikSplineHandle.
        
        - parentCurve : pcv              (bool)          [create]
            Specifies if the curve should automatically be parented to the parent of the
            first joint affected by the ikSplineHandle.
        
        - positionWeight : pw            (float)         [create,query,edit]
            Specifies the position/orientation weight of a handle. This is used to compute
            the distancebetween the goal position and the end-effector position.  A
            positionWeight of 1.0 computes the distance as the distance between positions
            only and ignores the orientations.  A positionWeight of 0.0 computes the
            distance as the distance between the orientations only and ignores the
            positions.  A positionWeight of 0.5 attempts to weight the distances equally but
            cannot actually compute this due to unit differences. Because there is no way to
            add linear units and angular units.
        
        - priority : p                   (int)           [create,query,edit]
            Sets the priority of the handle.  Logically, all handles with a lower number
            priority are solved before any handles with a higher numbered priority.  (All
            handles of priority 1 are solved before any handles of priority 2 and so on.)
            Handle priorities must be ] 0.
        
        - rootOnCurve : roc              (bool)          [create,query,edit]
            Specifies if the root is locked onto the curve of the ikSplineHandle.
        
        - rootTwistMode : rtm            (bool)          [create,query,edit]
            Specifies whether the start joint is allowed to twist or not. If not, then the
            required twist is distributed over the remaining joints. This applies to all the
            twist types.
        
        - setupForRPsolver : srp         (bool)          [edit]
            If the flag is set and ikSolver is ikRPsolver, call RPRotateSetup for the new
            ikHandle. It is for ikRPsolver only.
        
        - simplifyCurve : scv            (bool)          [create]
            Specifies if the ikSplineHandle curve should be simplified.
        
        - snapCurve : snc                (bool)          [create]
            Specifies if the curve should automatically snap to the first joint affected by
            the ikSplineHandle.
        
        - snapHandleFlagToggle : shf     (bool)          [create,query,edit]
            Specifies that the handle position should be snapped to the end-effector
            position if the end-effector is moved by the user.  Setting this flag on allows
            you to use forward kinematics to pose or adjust your skeleton and then to
            animate it with inverse kinematics.
        
        - snapHandleToEffector : see     (bool)          [edit]
            All handles are immediately moved so that the handle position and orientation
            matches the end-effector position and orientation.
        
        - solver : sol                   (unicode)       [create,query,edit]
            Specifies the solver.  The complete list of available solvers may not be known
            until run-time because some of the solvers may be implemented as plug-ins.
            Currently the only valid solver are ikRPsolver, ikSCsolver and ikSplineSolver.
        
        - startJoint : sj                (unicode)       [create,query,edit]
            Specifies the start joint of the handle's joint chain.
        
        - sticky : s                     (unicode)       [create,query,edit]
            Specifies that this handle is sticky. Valid values are off, sticky, superSticky.
            Sticky handles are solved when the skeleton is being manipulated interactively.
            If a character has sticky feet, the solver will attempt to keep them in the same
            position as the user moves the character's root.  If they were not sticky, they
            would move along with the root.
        
        - twistType : tws                (unicode)       [create,query,edit]
            Specifies the type of interpolation to be used by the ikSplineHandle.  The
            interpolation options are linear, easeIn, easeOut, and easeInOut.
        
        - weight : w                     (float)         [create,query,edit]
            Specifies the handles weight in error calculations.  The weight only applies
            when handle goals are in conflict and cannot be solved simultaneously.  When
            this happens, a solution is computed that weights the distancefrom each goal to
            the solution by the handle's weight and attempts to minimize this value.  The
            weight must be ]= 0.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.ikHandle`
        """
        pass
    Stickiness = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DagContainer(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMoveEdge(PolyMoveVertex):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getGain(self, **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalCenter(self, **kwargs):
        """
        Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalDirection(self, **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalDirectionX(self, **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalDirectionY(self, **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalDirectionZ(self, **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalRotate(self, **kwargs):
        """
        The local rotations. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalRotateX(self, **kwargs):
        """
        Local rotate X coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalRotateY(self, **kwargs):
        """
        Local rotate Y coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalRotateZ(self, **kwargs):
        """
        Local rotate Z coord : Rotation along the normal. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalScale(self, **kwargs):
        """
        Local Scale. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalScaleX(self, **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalScaleY(self, **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalScaleZ(self, **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalTranslate(self, **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalTranslateX(self, **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalTranslateY(self, **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getLocalTranslateZ(self, **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getPivotX(self, **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getPivotY(self, **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getPivotZ(self, **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getRandom(self, **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getRotate(self, **kwargs):
        """
        Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getRotateX(self, **kwargs):
        """
        Rotation angle around X.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getRotateY(self, **kwargs):
        """
        Rotation angle around Y.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getRotateZ(self, **kwargs):
        """
        Rotation angle around Z.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getScale(self, **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getScaleX(self, **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getScaleY(self, **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getScaleZ(self, **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getTranslate(self, **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getTranslateX(self, **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getTranslateY(self, **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getTranslateZ(self, **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setGain(self, val='True', **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalCenter(self, val='True', **kwargs):
        """
        Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalDirection(self, val='True', **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalDirectionX(self, val='True', **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalDirectionY(self, val='True', **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalDirectionZ(self, val='True', **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalRotate(self, val='True', **kwargs):
        """
        The local rotations. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalRotateX(self, val='True', **kwargs):
        """
        Local rotate X coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalRotateY(self, val='True', **kwargs):
        """
        Local rotate Y coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalRotateZ(self, val='True', **kwargs):
        """
        Local rotate Z coord : Rotation along the normal. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalScale(self, val='True', **kwargs):
        """
        Local Scale. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalScaleX(self, val='True', **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalScaleY(self, val='True', **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalScaleZ(self, val='True', **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalTranslate(self, val='True', **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalTranslateX(self, val='True', **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalTranslateY(self, val='True', **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setLocalTranslateZ(self, val='True', **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setPivotX(self, val='True', **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setPivotY(self, val='True', **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setPivotZ(self, val='True', **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setRandom(self, val='True', **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setRotate(self, val='True', **kwargs):
        """
        Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setRotateX(self, val='True', **kwargs):
        """
        Rotation angle around X.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setRotateY(self, val='True', **kwargs):
        """
        Rotation angle around Y.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setRotateZ(self, val='True', **kwargs):
        """
        Rotation angle around Z.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setScaleX(self, val='True', **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setScaleY(self, val='True', **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setScaleZ(self, val='True', **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setTranslate(self, val='True', **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setTranslateX(self, val='True', **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setTranslateY(self, val='True', **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setTranslateZ(self, val='True', **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Modifies edges of a polygonal object. Translate, move, rotate or scale edges.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - frozen : fzn                   (bool)          []
        
        - gain : ga                      (float)         [create,query,edit]
            Gain factor per component. Can be painted using Artisan. Default:1.0
        
        - localCenter : lc               (int)           [create,query,edit]
            Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0
        
        - localDirection : ld            (float, float, float) [create,query,edit]
            Direction to determine X axis for local space. Default:1.0, 0.0, 0.0
        
        - localDirectionX : ldx          (float)         [create,query,edit]
            X coord of the X axis.
        
        - localDirectionY : ldy          (float)         [create,query,edit]
            Y coord of the X axis.
        
        - localDirectionZ : ldz          (float)         [create,query,edit]
            Z coord of the X axis.
        
        - localRotate : lr               (float, float, float) [create,query,edit]
            The local rotations. Default:0.0, 0.0, 0.0
        
        - localRotateX : lrx             (float)         [create,query,edit]
            Local rotate X coord. The range is [0, 360].
        
        - localRotateY : lry             (float)         [create,query,edit]
            Local rotate Y coord. The range is [0, 360].
        
        - localRotateZ : lrz             (float)         [create,query,edit]
            Local rotate Z coord : Rotation along the normal. The range is [0, 360].
        
        - localScale : ls                (float, float, float) [create,query,edit]
            Local Scale. Default:1.0, 1.0, 1.0
        
        - localScaleX : lsx              (float)         [create,query,edit]
            Scale X coord.
        
        - localScaleY : lsy              (float)         [create,query,edit]
            Scale Y coord.
        
        - localScaleZ : lsz              (float)         [create,query,edit]
            Scale Z coord.
        
        - localTranslate : lt            (float, float, float) [create,query,edit]
            Local translate. Default:0.0, 0.0, 0.0
        
        - localTranslateX : ltx          (float)         [create,query,edit]
            Local translation X coord.
        
        - localTranslateY : lty          (float)         [create,query,edit]
            Local translation Y coord.
        
        - localTranslateZ : ltz          (float)         [create,query,edit]
            Local translation Z coord : Move along the normal.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - pivot : pvt                    (float, float, float) [create,query,edit]
            The pivot for scaling and rotation. Default:0.0, 0.0, 0.0
        
        - pivotX : pvx                   (float)         [create,query,edit]
            Pivot X coord.
        
        - pivotY : pvy                   (float)         [create,query,edit]
            Pivot Y coord.
        
        - pivotZ : pvz                   (float)         [create,query,edit]
            Pivot Z coord.
        
        - random : ran                   (float)         [create,query,edit]
            Random value for all parameters. Default:0.0
        
        - rotate : ro                    (float, float, float) [create,query,edit]
            Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0
        
        - rotateX : rx                   (float)         [create,query,edit]
            Rotation angle around X.
        
        - rotateY : ry                   (float)         [create,query,edit]
            Rotation angle around Y.
        
        - rotateZ : rz                   (float)         [create,query,edit]
            Rotation angle around Z.
        
        - scale : s                      (float, float, float) [create,query,edit]
            Scaling vector. Default:1.0, 1.0, 1.0
        
        - scaleX : sx                    (float)         [create,query,edit]
            Scale X coord.
        
        - scaleY : sy                    (float)         [create,query,edit]
            Scale Y coord.
        
        - scaleZ : sz                    (float)         [create,query,edit]
            Scale Z coord.
        
        - translate : t                  (float, float, float) [create,query,edit]
            Translation vector. Default:0.0, 0.0, 0.0
        
        - translateX : tx                (float)         [create,query,edit]
            Translation X coord.
        
        - translateY : ty                (float)         [create,query,edit]
            Translation Y coord.
        
        - translateZ : tz                (float)         [create,query,edit]
            Translation Z coord.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMoveEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyFlipUV(PolyModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getCutUV(self, **kwargs):
        """
        Cut UV edges when flipping some components on a UV shell C: Default is on. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getFlipType(self, **kwargs):
        """
        Flip along U or V direction. 0Horizontal1VerticalC: Default is 0. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getLocal(self, **kwargs):
        """
        Flips in the local space of the input faces. C: Default is on. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getPivotU(self, **kwargs):
        """
        Specifies the pivot value, in the U direction.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getPivotV(self, **kwargs):
        """
        Specifies the pivot value, in the V direction.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getUsePivot(self, **kwargs):
        """
        Flip using pivot or not. C: Default is off. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setCutUV(self, val='True', **kwargs):
        """
        Cut UV edges when flipping some components on a UV shell C: Default is on. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setFlipType(self, val='True', **kwargs):
        """
        Flip along U or V direction. 0Horizontal1VerticalC: Default is 0. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setLocal(self, val='True', **kwargs):
        """
        Flips in the local space of the input faces. C: Default is on. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setPivotU(self, val='True', **kwargs):
        """
        Specifies the pivot value, in the U direction.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setPivotV(self, val='True', **kwargs):
        """
        Specifies the pivot value, in the V direction.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setUsePivot(self, val='True', **kwargs):
        """
        Flip using pivot or not. C: Default is off. Q: When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flip (mirror) the UVs (in texture space) of input polyFaces, about either the U
        or V axis..
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createNewMap : cm              (bool)          [create]
            Set to true if a new map should be created
        
        - cutUV : cut                    (bool)          [create,query,edit]
            Cut UV edges when flipping some components on a UV shell C: Default is on. Q:
            When queried, returns an int.
        
        - flipType : ft                  (int)           [create,query,edit]
            Flip along U or V direction. 0Horizontal1VerticalC: Default is 0. Q: When
            queried, returns an int.
        
        - frozen : fzn                   (bool)          []
        
        - insertBeforeDeformers : ibd    (bool)          [create]
            Set to true if the new node created should inserted before any deformer nodes.
        
        - local : l                      (bool)          [create,query,edit]
            Flips in the local space of the input faces. C: Default is on. Q: When queried,
            returns an int.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - pivotU : pu                    (float)         [create,query,edit]
            Specifies the pivot value, in the U direction.
        
        - pivotV : pv                    (float)         [create,query,edit]
            Specifies the pivot value, in the V direction.
        
        - usePivot : up                  (bool)          [create,query,edit]
            Flip using pivot or not. C: Default is off. Q: When queried, returns an int.
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyFlipUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdMapSewMove(SubdModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def getLimitPieceSize(self, **kwargs):
        """
        When on, this flag specifies that the face number limit described above should be used.                  
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def getNumberFaces(self, **kwargs):
        """
        Maximum number of faces in a UV piece. When trying to combine two UV pieces into a single one, the merge operation is rejected if the smaller piece has more faces than the number specified by this flag.This flag is only used when limitPieceSizeis set to on.                  
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        If true, performs the operation in world space coordinates as opposed to local space.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def setLimitPieceSize(self, val='True', **kwargs):
        """
        When on, this flag specifies that the face number limit described above should be used.                  
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def setNumberFaces(self, val='True', **kwargs):
        """
        Maximum number of faces in a UV piece. When trying to combine two UV pieces into a single one, the merge operation is rejected if the smaller piece has more faces than the number specified by this flag.This flag is only used when limitPieceSizeis set to on.                  
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        If true, performs the operation in world space coordinates as opposed to local space.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command can be used to Move and Sew together separate UV pieces along
        geometric edges. UV pieces that correspond to the same geometric edge, are
        merged together by moving the smaller piece to the larger one. The argument is a
        UV selection list.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - frozen : fzn                   (bool)          []
        
        - limitPieceSize : lps           (bool)          [create,query,edit]
            When on, this flag specifies that the face number limit described above should
            be used.
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - numberFaces : nf               (int)           [create,query,edit]
            Maximum number of faces in a UV piece. When trying to combine two UV pieces into
            a single one, the merge operation is rejected if the smaller piece has more
            faces than the number specified by this flag.This flag is only used when
            limitPieceSizeis set to on.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            If true, performs the operation in world space coordinates as opposed to local
            space.                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.subdMapSewMove`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Instancer(Transform):
    def addObject(self, val='True', **kwargs):
        """
        This flag indicates that objects specified by the -object flag will be added to the instancer node as instanced objects.                                   
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def allInstances(self):
        """
        Returns information about all instances generated by a particular particle instancer node. Since many particles will typically instance similar sets of paths, the information is returned in a compact representation. An array of paths is returned, representing the unique set of paths that are instanced by any particle in the system. For each particle, the routine returns a set of indices into this path array to illustrate the paths instanced at that particle. The index arrays for all particles are concatenated together, so a "start index" array is used to indicate which is the first entry in the index array for each particle. For each particle, the routine also returns the transformation matrix applied to that particle's instanced paths to generate the final particle instance transformations.
        
        Returns:
        Tuple[List['PyNode'], List['Matrix'], List['int'], List['int']]
        
        Derived from api method `maya.OpenMayaFX.MFnInstancer.allInstances`
        """
        pass
    def getCycle(self, **kwargs):
        """
        This flag sets or queries the cycle attribute for the instancer node. The options are noneor sequential.  The default is none.                             
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getCycleStep(self, **kwargs):
        """
        This flag sets or queries the cycle step attribute for the instancer node.  This attribute indicates the size of the step in frames or seconds (see cycleStepUnit).                                
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getCycleStepUnits(self, **kwargs):
        """
        This flag sets or queries the cycle step unit attribute for the instancer node.  The options are framesor seconds.  The default is frames.                                 
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getIndex(self, **kwargs):
        """
        This flag is used to query the name of the ith instanced object.                                   
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getLevelOfDetail(self, **kwargs):
        """
        This flag sets or queries the level of detail of the instanced objects.  The options are geometry, boundingBox, boundingBoxes.  The default is geometry.                                   
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getObject(self, **kwargs):
        """
        This flag indicates which objects will be add/removed from the list of instanced objects.  The flag is used in conjuction with the -add and -remove flags.  If neither of these flags is specified on the command line then -add is assumed.                               
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getObjectPosition(self, **kwargs):
        """
        This flag queries the given objects position.  This object can be any instanced object or sub-object.                              
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getObjectRotation(self, **kwargs):
        """
        This flag queries the given objects rotation.  This object can be any instanced object or sub-object.                              
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getObjectScale(self, **kwargs):
        """
        This flag queries the given objects scale.  This object can be any instanced object or sub-object.                                 
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getPointDataSource(self, **kwargs):
        """
        This flag is used to query the source node supply the data for the input points.                                   
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getRotationUnits(self, **kwargs):
        """
        This flag specifies the rotation units associated with the rotation flag.  The options are degrees or radians.  By default the attribute is degrees.                               
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def getValueName(self, **kwargs):
        """
        This flag is used to query the value(s) of the array associated with the given name.  If the -index flag is used in conjuction with this flag then the ith value will be returned.  Otherwise, the entire array will be returned.                                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def instancesForParticle(self, p):
        """
        Returns the DAG paths and instancer matrix for all instances generated by a specified particle
        
        Parameters:
        p : 'int'
            The index of the particle being queried.
        
        
        Returns:
        Tuple['int', List['PyNode'], 'Matrix']
        
        Derived from api method `maya.OpenMayaFX.MFnInstancer.instancesForParticle`
        """
        pass
    def particleCount(self):
        """
        Returns the number of particles feeding the active instancer
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaFX.MFnInstancer.particleCount`
        """
        pass
    def removeObject(self, val='True', **kwargs):
        """
        This flag indicates that objects specified by the -object flag will be removed from the instancer node as instanced objects.                               
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def setCycle(self, val='True', **kwargs):
        """
        This flag sets or queries the cycle attribute for the instancer node. The options are noneor sequential.  The default is none.                             
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def setCycleStep(self, val='True', **kwargs):
        """
        This flag sets or queries the cycle step attribute for the instancer node.  This attribute indicates the size of the step in frames or seconds (see cycleStepUnit).                                
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def setCycleStepUnits(self, val='True', **kwargs):
        """
        This flag sets or queries the cycle step unit attribute for the instancer node.  The options are framesor seconds.  The default is frames.                                 
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def setLevelOfDetail(self, val='True', **kwargs):
        """
        This flag sets or queries the level of detail of the instanced objects.  The options are geometry, boundingBox, boundingBoxes.  The default is geometry.                                   
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def setObject(self, val='True', **kwargs):
        """
        This flag indicates which objects will be add/removed from the list of instanced objects.  The flag is used in conjuction with the -add and -remove flags.  If neither of these flags is specified on the command line then -add is assumed.                               
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    def setRotationUnits(self, val='True', **kwargs):
        """
        This flag specifies the rotation units associated with the rotation flag.  The options are degrees or radians.  By default the attribute is degrees.                               
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create a instancer node and set the proper attributes in
        the node.
        
        Flags:
        - addObject : a                  (bool)          [create,edit]
            This flag indicates that objects specified by the -object flag will be added to
            the instancer node as instanced objects.
        
        - cycle : c                      (unicode)       [create,query,edit]
            This flag sets or queries the cycle attribute for the instancer node. The
            options are noneor sequential.  The default is none.
        
        - cycleStep : cs                 (float)         [create,query,edit]
            This flag sets or queries the cycle step attribute for the instancer node.  This
            attribute indicates the size of the step in frames or seconds (see
            cycleStepUnit).
        
        - cycleStepUnits : csu           (unicode)       [create,query,edit]
            This flag sets or queries the cycle step unit attribute for the instancer node.
            The options are framesor seconds.  The default is frames.
        
        - index : i                      (int)           [query]
            This flag is used to query the name of the ith instanced object.
        
        - levelOfDetail : lod            (unicode)       [create,query,edit]
            This flag sets or queries the level of detail of the instanced objects.  The
            options are geometry, boundingBox, boundingBoxes.  The default is geometry.
        
        - name : n                       (unicode)       [create,query]
            This flag sets or queries the name of the instancer node.
        
        - object : obj                   (unicode)       [create,query,edit]
            This flag indicates which objects will be add/removed from the list of instanced
            objects.  The flag is used in conjuction with the -add and -remove flags.  If
            neither of these flags is specified on the command line then -add is assumed.
        
        - objectPosition : op            (unicode)       [query]
            This flag queries the given objects position.  This object can be any instanced
            object or sub-object.
        
        - objectRotation : objectRotation (unicode)       [query]
            This flag queries the given objects rotation.  This object can be any instanced
            object or sub-object.
        
        - objectScale : os               (unicode)       [query]
            This flag queries the given objects scale.  This object can be any instanced
            object or sub-object.
        
        - pointDataSource : pds          (bool)          [query]
            This flag is used to query the source node supply the data for the input points.
        
        - removeObject : rm              (bool)          [edit]
            This flag indicates that objects specified by the -object flag will be removed
            from the instancer node as instanced objects.
        
        - rotationOrder : ro             (unicode)       [create,query,edit]
            This flag specifies the rotation order associated with the rotation flag.  The
            options are XYZ, XZY, YXZ, YZX, ZXY, or ZYX.  By default the attribute is XYZ.
        
        - rotationUnits : ru             (unicode)       [create,query,edit]
            This flag specifies the rotation units associated with the rotation flag.  The
            options are degrees or radians.  By default the attribute is degrees.
        
        - valueName : vn                 (unicode)       [query]
            This flag is used to query the value(s) of the array associated with the given
            name.  If the -index flag is used in conjuction with this flag then the ith
            value will be returned.  Otherwise, the entire array will be returned.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.instancer`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ClusterHandle(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class LineModifier(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class HikIKEffector(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class LightGroup(LightItemBase):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HikHandle(Transform):
    """
    # TODO: if hikHandle bug ever fixed:
    #   - remove entry in apiCache.ApiCache.API_TO_MFN_OVERRIDES
    #   - remove hard-code setting of HikHandle's parent to Transform
    """
    
    
    
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class UfeProxyTransform(Transform):
    __melnode__ = []
    
    
    __readonly__ = {}


class FosterParent(Transform):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMergeUV(PolyModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def getDistance(self, **kwargs):
        """
        This flag specifies the maximum distance to merge UVs. C: Default is 0.0. Q: When queried, this flag returns a double.                  
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def setDistance(self, val='True', **kwargs):
        """
        This flag specifies the maximum distance to merge UVs. C: Default is 0.0. Q: When queried, this flag returns a double.                  
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Merge UVs of an object based on their distance. UVs are merge only if they
        belong to the same 3D vertex.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - distance : d                   (float)         [create,query,edit]
            This flag specifies the maximum distance to merge UVs. C: Default is 0.0. Q:
            When queried, this flag returns a double.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyMergeUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GeoConnectable(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCopyUV(PolyModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def getUvSetNameInput(self, **kwargs):
        """
        Specifies name of the input uv set to read the UV description from. Default is the current UV set.                  
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def setUvSetNameInput(self, val='True', **kwargs):
        """
        Specifies name of the input uv set to read the UV description from. Default is the current UV set.                  
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Copy some UVs from a UV set into another.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createNewMap : cm              (bool)          [create]
            Set to true if a new map should be created
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - uvSetNameInput : uvi           (unicode)       [create,query,edit]
            Specifies name of the input uv set to read the UV description from. Default is
            the current UV set.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyCopyUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class IkEffector(Transform):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdAutoProj(SubdModifierUV):
    __melnode__ = []
    
    
    __readonly__ = {}


class LodGroup(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyContourProj(PolyModifierUV):
    __melnode__ = []
    
    
    __readonly__ = {}


class PfxGeometry(Shape):
    def getBoundingBox(self):
        """
        Gets the bounding box of the specified geometry. The passed in double arrays will be filled with minimum and maximum coordinates of the geometry.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMayaFX.MFnPfxGeometry.getBoundingBox`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ClipGhostShape(Transform):
    __melnode__ = []
    
    
    __readonly__ = {}


class Spring(Shape):
    def allPoints(self, val='True', **kwargs):
        """
        If True, sets the mode of spring application to All.  This will add springs between all points selected. (Default is False.)                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getCount(self, **kwargs):
        """
        Return the number of springs in the shape.  Query-only. We maintain this flag only for compatibility with earlier versions of Maya.  To get the count of springs, it is much faster and simpler to use the spring shape's count attribute: getAttr shapeName.count.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getDamping(self, **kwargs):
        """
        Damping factor for the springs created in the spring object. (Default = 0.2 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getDampingPS(self, **kwargs):
        """
        Damping factor for the springs created in the spring object. This will initialize all the entries in dampingPS to the specified value. In both the flag and the attribute name, PSstands for per-spring.(Default = 0.2 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getEndForceWeight(self, **kwargs):
        """
        Amount of the force of the spring that gets applied to the point to which the spring ends. Valid range is from 0.0 to 1.0. (Default = 1.0 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getLength(self, **kwargs):
        """
        Vestigial form of restLength.Please use restLengthinstead.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getRestLength(self, **kwargs):
        """
        Per-object rest length for the new springs. Springs can use either their per-object or per-spring rest length.  See the -lPS and -ulp flags.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getRestLengthPS(self, **kwargs):
        """
        Per-spring rest length for the new springs. This will initialize all the entries in restLengthPS to the specified value. If this flag is not thrown, each rest length will be initialized to the distance between the two  points at the time the spring is created (i.e., the initial length of the spring).   When playing back, springs can use either their per-spring or per-object rest length.  See the -rl and -urp flags. In both the flag and the attribute name, PSstands for per-spring.
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getStartForceWeight(self, **kwargs):
        """
        Amount of the force of the spring that gets applied to the point from which the spring starts. Valid range is from 0.0 to 1.0. (Default = 1.0 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getStiffness(self, **kwargs):
        """
        Stiffness of the springs created in the spring object. (Default = 1.0 ) -damp float Vestigial form of damping.Please use dampinginstead.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getStiffnessPS(self, **kwargs):
        """
        Stiffness of the springs created in the spring object. This will initialize all the entries in stiffnessPS to the specified value. In both the flag and the attribute name, PSstands for per-spring.(Default = 1.0 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getUseDampingPS(self, **kwargs):
        """
        Specifies whether to use dampingPS (per spring damping). If set to false, the per object damping attribute value will be used. This flag simply sets the useDampingPS attribute of the spring shape. In both the flag and the attribute name, PSstands for per-spring.(Default = false )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getUseRestLengthPS(self, **kwargs):
        """
        Specifies whether to use restLengthPS (per spring restLength). If set to false, the per object restLength attribute value will be used. This flag simply sets the useRestLengthPS attribute of the spring shape. In both the flag and the attribute name, PSstands for per-spring.(Default = false )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def getUseStiffnessPS(self, **kwargs):
        """
        Specifies whether to use stiffnessPS (per spring stiffness). If set to false, the per object stiffness attribute value will be used. This flag simply sets the useStiffnessPS attribute of the spring shape. In both the flag and the attribute name, PSstands for per-spring.(Default = false )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def maxDistance(self, val='True', **kwargs):
        """
        Maximum distance between two points that a spring would be considered.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setDamping(self, val='True', **kwargs):
        """
        Damping factor for the springs created in the spring object. (Default = 0.2 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setDampingPS(self, val='True', **kwargs):
        """
        Damping factor for the springs created in the spring object. This will initialize all the entries in dampingPS to the specified value. In both the flag and the attribute name, PSstands for per-spring.(Default = 0.2 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setEndForceWeight(self, val='True', **kwargs):
        """
        Amount of the force of the spring that gets applied to the point to which the spring ends. Valid range is from 0.0 to 1.0. (Default = 1.0 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setLength(self, val='True', **kwargs):
        """
        Vestigial form of restLength.Please use restLengthinstead.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setRestLength(self, val='True', **kwargs):
        """
        Per-object rest length for the new springs. Springs can use either their per-object or per-spring rest length.  See the -lPS and -ulp flags.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setRestLengthPS(self, val='True', **kwargs):
        """
        Per-spring rest length for the new springs. This will initialize all the entries in restLengthPS to the specified value. If this flag is not thrown, each rest length will be initialized to the distance between the two  points at the time the spring is created (i.e., the initial length of the spring).   When playing back, springs can use either their per-spring or per-object rest length.  See the -rl and -urp flags. In both the flag and the attribute name, PSstands for per-spring.
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setStartForceWeight(self, val='True', **kwargs):
        """
        Amount of the force of the spring that gets applied to the point from which the spring starts. Valid range is from 0.0 to 1.0. (Default = 1.0 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setStiffness(self, val='True', **kwargs):
        """
        Stiffness of the springs created in the spring object. (Default = 1.0 ) -damp float Vestigial form of damping.Please use dampinginstead.                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setStiffnessPS(self, val='True', **kwargs):
        """
        Stiffness of the springs created in the spring object. This will initialize all the entries in stiffnessPS to the specified value. In both the flag and the attribute name, PSstands for per-spring.(Default = 1.0 )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setUseDampingPS(self, val='True', **kwargs):
        """
        Specifies whether to use dampingPS (per spring damping). If set to false, the per object damping attribute value will be used. This flag simply sets the useDampingPS attribute of the spring shape. In both the flag and the attribute name, PSstands for per-spring.(Default = false )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setUseRestLengthPS(self, val='True', **kwargs):
        """
        Specifies whether to use restLengthPS (per spring restLength). If set to false, the per object restLength attribute value will be used. This flag simply sets the useRestLengthPS attribute of the spring shape. In both the flag and the attribute name, PSstands for per-spring.(Default = false )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    def setUseStiffnessPS(self, val='True', **kwargs):
        """
        Specifies whether to use stiffnessPS (per spring stiffness). If set to false, the per object stiffness attribute value will be used. This flag simply sets the useStiffnessPS attribute of the spring shape. In both the flag and the attribute name, PSstands for per-spring.(Default = false )                  
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The spring command can do any of the following:\* create a new spring object
        (shape plus transform).  The shape contains springs between the points
        (particles, cvs, etc.) of the objects selected or listed on the command line.\*
        create new springs and add them to an existing spring object\* edit or query
        certain attributes of an existing spring objectOne spring objectmay have
        hundreds or even thousands of individual springs. Certain attributes of the
        spring object specify exactly where the springs are attached to which other
        objects.Springs may be attached to the following: particles, vertices of soft
        bodies, CVs or edit points of curves or surfaces, vertices of polygonal objects,
        and points of lattices. In the case where one endpoint of a spring is non-
        dynamic (a CV, edit point, etc.), the spring does not affect its motion, but the
        motion of the point affects the spring. A spring will be created only if at
        least one of the endpoints is dynamic: for example, a spring will never be
        created between two CVs. A single spring object can hold springs which are
        incident to any number of other objects.The spring has creation-only flags and
        editable flags.  Creation-only flags (minDistance, maxDistance, add, exclusive,
        all, wireframe, walklength, checkExisting) can be used only when creating new
        springs (including adding springs to existing spring object).  Editable flags
        modify attributes of an existing spring object.If a spring object is created,
        this command returns the names of the shape and transform.  If a spring object
        is queried, the command returns the results of the query.
        
        Flags:
        - addSprings : add               (bool)          [create]
            If specified, springs will be added to the existing selected set of springs.
            (Default is to create a new spring object.)
        
        - allPoints : all                (bool)          [create,edit]
            If True, sets the mode of spring application to All.  This will add springs
            between all points selected. (Default is False.)
        
        - count : ct                     (bool)          [query]
            Return the number of springs in the shape.  Query-only. We maintain this flag
            only for compatibility with earlier versions of Maya.  To get the count of
            springs, it is much faster and simpler to use the spring shape's count
            attribute: getAttr shapeName.count.
        
        - damp : dmp                     (float)         []
        
        - damping : d                    (float)         [create,query,edit]
            Damping factor for the springs created in the spring object. (Default = 0.2 )
        
        - dampingPS : dPS                (float)         [create,query,edit]
            Damping factor for the springs created in the spring object. This will
            initialize all the entries in dampingPS to the specified value. In both the flag
            and the attribute name, PSstands for per-spring.(Default = 0.2 )
        
        - endForceWeight : efw           (float)         [create,query,edit]
            Amount of the force of the spring that gets applied to the point to which the
            spring ends. Valid range is from 0.0 to 1.0. (Default = 1.0 )
        
        - exclusive : exc                (bool)          [create]
            If true, tells the command to create springs only between pairs of points which
            are not in the same object. (Default is False.)
        
        - length : l                     (float)         [create,query,edit]
            Vestigial form of restLength.Please use restLengthinstead.
        
        - maxDistance : mxd              (float)         [create,edit]
            Maximum distance between two points that a spring would be considered.
        
        - minDistance : mnd              (float)         [create]
            Minimum distance between two points that a spring would be considered. (Default
            = 0.0. See Defaults for more information on this flag's default.)
        
        - minMax : mm                    (bool)          [create]
            If True, sets the mode of the spring application to Min/Max. This will add
            springs between all points from the specified point groups that are between the
            minimum and maximum distance values set with min and max. (Default is False.)
            Note: This gets automatically set if either the min or max flags are used.
        
        - name : n                       (unicode)       [create,query]
            Name of spring object.
        
        - noDuplicate : nd               (bool)          [create]
            Check for existing springs and don't add a new spring between two points already
            connected by a spring in the same object. Only the object the command is working
            on is checked.  This flag is relevant only when using -add. (Default = false)
        
        - restLength : rl                (float)         [create,query,edit]
            Per-object rest length for the new springs. Springs can use either their per-
            object or per-spring rest length.  See the -lPS and -ulp flags.
        
        - restLengthPS : rPS             (float)         [create,query,edit]
            Per-spring rest length for the new springs. This will initialize all the entries
            in restLengthPS to the specified value. If this flag is not thrown, each rest
            length will be initialized to the distance between the two  points at the time
            the spring is created (i.e., the initial length of the spring).   When playing
            back, springs can use either their per-spring or per-object rest length.  See
            the -rl and -urp flags. In both the flag and the attribute name, PSstands for
            per-spring.
        
        - startForceWeight : sfw         (float)         [create,query,edit]
            Amount of the force of the spring that gets applied to the point from which the
            spring starts. Valid range is from 0.0 to 1.0. (Default = 1.0 )
        
        - stiffness : s                  (float)         [create,query,edit]
            Stiffness of the springs created in the spring object. (Default = 1.0 ) -damp
            float Vestigial form of damping.Please use dampinginstead.
        
        - stiffnessPS : sPS              (float)         [create,query,edit]
            Stiffness of the springs created in the spring object. This will initialize all
            the entries in stiffnessPS to the specified value. In both the flag and the
            attribute name, PSstands for per-spring.(Default = 1.0 )
        
        - strength : str                 (float)         []
        
        - useDampingPS : udp             (bool)          [create,query,edit]
            Specifies whether to use dampingPS (per spring damping). If set to false, the
            per object damping attribute value will be used. This flag simply sets the
            useDampingPS attribute of the spring shape. In both the flag and the attribute
            name, PSstands for per-spring.(Default = false )
        
        - useRestLengthPS : urp          (bool)          [create,query,edit]
            Specifies whether to use restLengthPS (per spring restLength). If set to false,
            the per object restLength attribute value will be used. This flag simply sets
            the useRestLengthPS attribute of the spring shape. In both the flag and the
            attribute name, PSstands for per-spring.(Default = false )
        
        - useStiffnessPS : usp           (bool)          [create,query,edit]
            Specifies whether to use stiffnessPS (per spring stiffness). If set to false,
            the per object stiffness attribute value will be used. This flag simply sets the
            useStiffnessPS attribute of the spring shape. In both the flag and the attribute
            name, PSstands for per-spring.(Default = false )
        
        - walkLength : wl                (int)           [create]
            This flag is valid only when doing wireframe creation. It will create springs
            between pairs of points connected by the specified number of edges.  For
            example, if walk length is 2, each pair of points separated by no more than 2
            edges will get a spring.  Walk length measures the distance between pairs of
            vertices just like the number of blocks measures the distance between two
            intersections in a city.
        
        - wireframe : wf                 (bool)          [create]
            If True, sets the mode of the spring application to Wireframe. This is valid
            only for springs created on a soft body. It will add springs along all edges
            connecting the adjacent points (vertices or CV's) of curves and surfaces.
            (Default is False.)                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.spring`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GeometryShape(Shape):
    def __getattr__(self, attr): pass
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformFunc(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class ValueOverride(Override):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyNormalizeUV(PolyModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def getCenterOnTile(self, **kwargs):
        """
        If true, will center UV's on the UV tile they are most over. If false, will center UV's in the 0-1 region.                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def getNormalizeDirection(self, **kwargs):
        """
        Scale along U or V or both. 0UV1U2VC:  Default is 0. Q:  When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def getNormalizeType(self, **kwargs):
        """
        Options for normalize. 0Separate1CollectiveC:  Default is 1. Q:  When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def getPreserveAspectRatio(self, **kwargs):
        """
        Scale uniform along u and v. C: Default is on. Q: When queried, returns an int.                  Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def setCenterOnTile(self, val='True', **kwargs):
        """
        If true, will center UV's on the UV tile they are most over. If false, will center UV's in the 0-1 region.                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def setNormalizeDirection(self, val='True', **kwargs):
        """
        Scale along U or V or both. 0UV1U2VC:  Default is 0. Q:  When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def setNormalizeType(self, val='True', **kwargs):
        """
        Options for normalize. 0Separate1CollectiveC:  Default is 1. Q:  When queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def setPreserveAspectRatio(self, val='True', **kwargs):
        """
        Scale uniform along u and v. C: Default is on. Q: When queried, returns an int.                  Common poly modifier operation flags
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Normalizes the UVs of input polyFaces. The existing UVs of the faces are
        normalized between 0 and 1.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - centerOnTile : cot             (bool)          [create,query,edit]
            If true, will center UV's on the UV tile they are most over. If false, will
            center UV's in the 0-1 region.
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createNewMap : cm              (bool)          [create]
            Set to true if a new map should be created
        
        - frozen : fzn                   (bool)          []
        
        - insertBeforeDeformers : ibd    (bool)          [create]
            Set to true if the new node created should inserted before any deformer nodes.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - normalizeDirection : nd        (int)           [create,query,edit]
            Scale along U or V or both. 0UV1U2VC:  Default is 0. Q:  When queried, returns
            an int.
        
        - normalizeType : nt             (int)           [create,query,edit]
            Options for normalize. 0Separate1CollectiveC:  Default is 1. Q:  When queried,
            returns an int.
        
        - preserveAspectRatio : pa       (bool)          [create,query,edit]
            Scale uniform along u and v. C: Default is on. Q: When queried, returns an int.
            Common poly modifier operation flags
        
        - uvSetName : uvs                (unicode)       [create]
            Name of the UV set to be created
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyNormalizeUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Camera(Shape):
    def addBookmark(self, bookmark='None'): pass
    def applyBookmark(self, bookmark): pass
    def computeDepthOfField(self):
        """
        Status code
        Derived from api method `maya.OpenMaya.MFnCamera.computeDepthOfField`
        """
        pass
    def copyViewFrom(self, otherCamera):
        """
        Copy the camera settings related to the perspective from the given camera view.
        
        Parameters:
        otherCamera : 'PyNode'
            Camera to copy view from
        
        Derived from api method `maya.OpenMaya.MFnCamera.copyViewFrom`
        """
        pass
    def dolly(self, distance, relative='True'):
        """
        The dolly command moves a camera along the viewing direction in the world space.
        The viewing-direction and up-direction of the camera are not altered. There are
        two modes of operation: Relative mode: for a perspective camera, the camera is
        moved along its viewing direction, and the distance of travel is computed with
        respect to the current position of the camera in the world space. In relative
        mode, when the camera is moved, its COI is moved along with it, and is kept at
        the same distance, in front of the camera, as before applying the dolly
        operation. For orthographic camera, the viewing width of the camera is changed
        by scaling its ortho width by the new value specified on the command line.
        Absolute mode: for a perspective camera, the camera is moved along its viewing
        direction, to the distance that is computed with respect to the current position
        of the world center of interest (COI) of the camera. In the absolute mode, when
        the camera is moved, the COI of the camera is not moved with the camera, but it
        is fixed at its current location in space. For orthographic camera, the viewing
        width of the camera is changed by replacing its ortho width with the new value
        specified on the command line. This command may be applied to more than one
        cameras; objects that are not cameras are ignored. When no camera name supplied
        on the command line, this command is applied to all currently active cameras.
        The dolly command can be applied to either a perspective or an orthographic
        camera.
        
        Flags:
        - absolute : abs                 (bool)          [create]
            This flag modifies the behavior of the distance and orthoScale flags. When used
            in conjunction with the distance flag, the distance argument specifies how far
            the camera's eye point should be set from the camera's center of interest. When
            used with the orthoScale flag, the orthoScale argument specifies the camera's
            new ortho width.
        
        - distance : d                   (float)         [create]
            Unit distance to dolly a perspective camera.
        
        - dollyTowardsCenter : dtc       (bool)          [create]
            This flag controls whether the dolly is performed towards the center of the view
            (if true), or towards the point where the user clicks (if false). By default,
            dollyTowardsCenter is on.
        
        - orthoScale : os                (float)         [create]
            Scale to change the ortho width of an orthographic camera.
        
        - relative : rel                 (bool)          [create]
            This flag modifies the behavior of the distance and orthoScale flags. When used
            in conjunction with the distance flag, the camera eye and center of interest are
            both moved by the amount specified by the distance flag's argument. When used
            with the orthoScale flag, the orthoScale argument is used multiply the camera's
            ortho width.By default the relative flag is always on.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.dolly`
        """
        pass
    def getAspectRatio(self):
        """
        Returns the aspect ratio for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.aspectRatio`
        """
        pass
    def getAspectRatioLimits(self):
        """
        Returns the minimum and maximum aspect ratio limits for the camera.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getAspectRatioLimits`
        """
        pass
    def getCameraScale(self):
        """
        Returns the camera scale.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.cameraScale`
        """
        pass
    def getCenterOfInterest(self):
        """
        Return the linear distance from the camera's eye point to the center of interest.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.centerOfInterest`
        """
        pass
    def getCenterOfInterestPoint(self, space="'preTransform'"):
        """
        Returns the center of interest point for the camera.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.centerOfInterestPoint`
        """
        pass
    def getDisplayFieldChart(self, **kwargs):
        """
        Activate display of the video field chart when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getDisplayFilmOrigin(self, **kwargs):
        """
        Activate the display of the film origin guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getDisplayFilmPivot(self, **kwargs):
        """
        Activate display of the film pivot guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getDisplayGateMask(self, **kwargs):
        """
        Display the gate mask, file or resolution, as a shaded area to the edge of the viewport.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getDisplayResolution(self, **kwargs):
        """
        Activate display of the current rendering resolution (as defined in the render globals) when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getDisplaySafeAction(self, **kwargs):
        """
        Activate display of the video Safe Action guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getDisplaySafeTitle(self, **kwargs):
        """
        Activate display of the video Safe Title guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getEyePoint(self, space="'preTransform'"):
        """
        Returns the eye point for the camera.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.eyePoint`
        """
        pass
    def getFStop(self):
        """
        Returns the f-stop value for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.fStop`
        """
        pass
    def getFarClipPlane(self):
        """
        Returns the distance to the far clipping plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.farClippingPlane`
        """
        pass
    def getFarClippingPlane(self):
        """
        Returns the distance to the far clipping plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.farClippingPlane`
        """
        pass
    def getFarFocusDistance(self):
        """
        Returns the linear distance to the far focus plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.farFocusDistance`
        """
        pass
    def getFilmApertureLimits(self):
        """
        Returns the maximum and minimum film aperture limits for the camera.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getFilmApertureLimits`
        """
        pass
    def getFilmFit(self):
        """
        Returns how the digital image is being fitted to the film back.
        
        Returns:
        'Camera.FilmFit'
        
        Derived from api method `maya.OpenMaya.MFnCamera.filmFit`
        """
        pass
    def getFilmFitOffset(self):
        """
        Returns the film fit offset for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.filmFitOffset`
        """
        pass
    def getFilmFrustum(self, distance, applyPanZoom='False'):
        """
        Returns the film frustum for the camera. The frustum defines the projective transformation.
        
        Parameters:
        distance : 'float'
            Specifies the focal length
        applyPanZoom : 'bool'
            specifies whether to apply 2D pan/zoom par Status Codes: MS::kSuccess The method was successful MS::kFailure An object error has occurred
        
        
        Returns:
        Tuple['float', 'float', 'float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getFilmFrustum`
        """
        pass
    def getFilmRollOrder(self):
        """
        Returns the current roll order
        
        Returns:
        'Camera.RollOrder'
        
        Derived from api method `maya.OpenMaya.MFnCamera.filmRollOrder`
        """
        pass
    def getFilmRollValue(self):
        """
        Returns the current roll value in angular units.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.filmRollValue`
        """
        pass
    def getFilmTranslateH(self):
        """
        Returns the horizontal film translate value. This value corresponds to the normalized viewport.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.filmTranslateH`
        """
        pass
    def getFilmTranslateV(self):
        """
        Returns the vertical film translate value. This value corresponds to the normalized viewport, [-1,1].
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.filmTranslateV`
        """
        pass
    def getFocalLength(self):
        """
        Returns the focal length for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.focalLength`
        """
        pass
    def getFocalLengthLimits(self):
        """
        Returns the focal length limits for the camera.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getFocalLengthLimits`
        """
        pass
    def getFocusDistance(self):
        """
        Returns the focus distance for the camera. This value sets the focus at a certain distance in front of the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.focusDistance`
        """
        pass
    def getHomeCommand(self, **kwargs):
        """
        Specify the command to execute when viewSet -homeis applied to this camera. All occurances of %camerawill be replaced with the cameras name before viewSet runs the command.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getHorizontalFieldOfView(self):
        """
        Returns the horizontal field of view for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.horizontalFieldOfView`
        """
        pass
    def getHorizontalFilmAperture(self):
        """
        Returns the horizontal film aperture for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.horizontalFilmAperture`
        """
        pass
    def getHorizontalFilmOffset(self):
        """
        Returns the horizontal offset of the film. Unit used is inches.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.horizontalFilmOffset`
        """
        pass
    def getHorizontalPan(self):
        """
        Return the camera 2D horizontal pan value. Unit is inches.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.horizontalPan`
        """
        pass
    def getHorizontalRollPivot(self):
        """
        Returns the current horizontal roll pivot value.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.horizontalRollPivot`
        """
        pass
    def getHorizontalShake(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.horizontalShake`
        """
        pass
    def getJournalCommand(self, **kwargs):
        """
        Journal interactive camera commands. Commands can be undone when a camera is journaled.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getLensSqueezeRatio(self):
        """
        Returns the lens squeeze ratio for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.lensSqueezeRatio`
        """
        pass
    def getLockTransform(self, **kwargs):
        """
        Lock the camera. When a camera is locked, its transformation information, that is, its Translate and Rotate properties cannot be adjusted, and the center of interest point cannot be moved. For orthographic cameras, Orthographic Width is also locked. For camera groups, Aim and Up locator's translate is also locked. For stereo cameras, the root camera is locked.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getNearClipPlane(self):
        """
        Returns the distance to the near clipping plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.nearClippingPlane`
        """
        pass
    def getNearClippingPlane(self):
        """
        Returns the distance to the near clipping plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.nearClippingPlane`
        """
        pass
    def getNearFocusDistance(self):
        """
        Returns the linear distance to the near focus plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.nearFocusDistance`
        """
        pass
    def getOrthoWidth(self):
        """
        Returns the orthographic projection width.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.orthoWidth`
        """
        pass
    def getOverscan(self):
        """
        Returns the percent of overscan for this camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.overscan`
        """
        pass
    def getPanZoomEnabled(self):
        """
        Return the toggle value for the camera 2D pan/zoom enabled attribute. If this attribute is false, the 2D pan/zoom values are ignored by the camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.panZoomEnabled`
        """
        pass
    def getPortFieldOfView(self, width, height):
        """
        Compute the horizontal and vertical field of view in angular units from the given viewport width and height.
        
        Parameters:
        width : 'int'
            width of viewport
        height : 'int'
            height of viewport
        
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getPortFieldOfView`
        """
        pass
    def getPostScale(self):
        """
        Return the post projection matrix's post-scale value.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.postScale`
        """
        pass
    def getPreScale(self):
        """
        Return the post projection matrix's pre-scale value.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.preScale`
        """
        pass
    def getRenderPanZoom(self):
        """
        Return the toggle value for the camera render 2D pan/zoom attribute. If this attribute is false, the 2D pan/zoom values will not affect the output render.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.renderPanZoom`
        """
        pass
    def getRenderingFrustum(self, windowAspect):
        """
        Computes and returns the rendering frustum for the camera. This is the frustum that the maya renderer uses.
        
        Parameters:
        windowAspect : 'float'
            windowAspect
        
        
        Returns:
        Tuple['float', 'float', 'float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getRenderingFrustum`
        """
        pass
    def getShakeEnabled(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.shakeEnabled`
        """
        pass
    def getShakeOverscan(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.shakeOverscan`
        """
        pass
    def getShakeOverscanEnabled(self):
        """
        Returns the toggle value for the camera shake overscan attribute. If this attribute is false, the shakeOverscan value is ignored by the camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.shakeOverscanEnabled`
        """
        pass
    def getShutterAngle(self):
        """
        Return the current shutter angle which is one of the variables used to compute motion blur. The shutter angle is specified in angular units.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.shutterAngle`
        """
        pass
    def getStartupCamera(self, **kwargs):
        """
        A startup camera is marked undeletable and implicit. This flag can be used to set or query the startup state of a camera. There must always be at least one startup camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getStereoHIT(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.stereoHIT`
        """
        pass
    def getStereoHITEnabled(self):
        """
        Returns the toggle value for the stereo HIT enabled attribute. If this attribute is false, the stereoHIT value is ignored by the camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.stereoHITEnabled`
        """
        pass
    def getTumblePivot(self):
        """
        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.
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MFnCamera.tumblePivot`
        """
        pass
    def getUsePivotAsLocalSpace(self):
        """
        Returns the value of the local axis tumble setting for this camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.usePivotAsLocalSpace`
        """
        pass
    def getVerticalFieldOfView(self):
        """
        Returns the vertical field of view for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.verticalFieldOfView`
        """
        pass
    def getVerticalFilmAperture(self):
        """
        Returns the vertical film aperture for the camera.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.verticalFilmAperture`
        """
        pass
    def getVerticalFilmOffset(self):
        """
        Change the vertical offset of the film. Unit used is inches.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.verticalFilmOffset`
        """
        pass
    def getVerticalPan(self):
        """
        Return the camera 2D vertical pan value. Unit is inches.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.verticalPan`
        """
        pass
    def getVerticalRollPivot(self):
        """
        Returns the vertical roll pivot's value.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.verticalRollPivot`
        """
        pass
    def getVerticalShake(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.verticalShake`
        """
        pass
    def getViewParameters(self, windowAspect, applyOverscan='False', applySqueeze='False', applyPanZoom='False'):
        """
        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:
        
        Parameters:
        windowAspect : 'float'
            windowAspect
        applyOverscan : 'bool'
            specifies whether to apply overscan
        applySqueeze : 'bool'
            specifies whether to apply the lens squeeze ratio of the camera applyPanZoom specifies whether to apply 2D pan/zoom
        applyPanZoom : 'bool'
            specifies whether to apply 2D pan/zoom par Status Codes: MS::kSuccess The method was successful MS::kFailure An object error has occurred
        
        
        Returns:
        Tuple['float', 'float', 'float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getViewParameters`
        """
        pass
    def getViewingFrustum(self, windowAspect, applyOverscan='False', applySqueeze='False', applyPanZoom='False'):
        """
        Computes and returns the viewing frustum for the camera.
        
        Parameters:
        windowAspect : 'float'
            windowAspect
        applyOverscan : 'bool'
            specifies whether to apply overscan
        applySqueeze : 'bool'
            specifies whether to apply the lens squeeze ratio of the camera
        applyPanZoom : 'bool'
            specifies whether to apply 2D pan/zoom par Status Codes: MS::kSuccess The method was successful MS::kFailure An object error has occurred
        
        
        Returns:
        Tuple['float', 'float', 'float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnCamera.getViewingFrustum`
        """
        pass
    def getWorldCenterOfInterest(self, **kwargs):
        """
        Camera world center of interest point.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getWorldUp(self, **kwargs):
        """
        Camera world up vector.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def getZoom(self):
        """
        Return the camera 2D zoom value, which is the percent over the film viewable frustum to display
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.zoom`
        """
        pass
    def hasSamePerspective(self, otherCamera):
        """
        Returns true if the camera has same perspective settings as the given camera.
        
        Parameters:
        otherCamera : 'PyNode'
            Camera to compare perspective with
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.hasSamePerspective`
        """
        pass
    def isClippingPlanes(self):
        """
        Determines whether manual clipping planes are activated.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isClippingPlanes`
        """
        pass
    def isDepthOfField(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isDepthOfField`
        """
        pass
    def isDisplayFilmGate(self):
        """
        Determines if the film gate icons are displayed when looking through the camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isDisplayFilmGate`
        """
        pass
    def isDisplayGateMask(self):
        """
        Determines if the film gate is displayed shaded.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isDisplayGateMask`
        """
        pass
    def isMotionBlur(self):
        """
        Determine if motion blur is on/off for the camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isMotionBlur`
        
        Aliases: isMotionBlur, isMotionBlurred
        """
        pass
    def isMotionBlurred(self):
        """
        Determine if motion blur is on/off for the camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isMotionBlur`
        
        Aliases: isMotionBlur, isMotionBlurred
        """
        pass
    def isOrtho(self):
        """
        Determines if the camera is in orthographic mode.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isOrtho`
        """
        pass
    def isVerticalLock(self):
        """
        Determines if vertical lock is turned on for the camera.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnCamera.isVerticalLock`
        """
        pass
    def listBookmarks(self): pass
    def orbit(*args, **kwargs):
        """
        The orbit command revolves the camera(s) horizontally and/or vertically in the
        perspective window. The rotation axis is with respect to the camera. To revolve
        horizontally: the rotation axis is the camera up direction vector. To revolve
        vertically: the rotation axis is the camera left direction vector. When both the
        horizontal and the vertical angles are supplied on the command line, the camera
        is firstly revolved horizontally, then revolved vertically. This command may be
        applied to more than one camera; objects that are not cameras are ignored. When
        no camera name supplied, this command is applied to all currently active
        cameras.
        
        Flags:
        - horizontalAngle : ha           (float)         [create]
            Angle to revolve horizontally.
        
        - pivotPoint : pp                (float, float, float) [create]
            Used as the pivot point in the world space.
        
        - rotationAngles : ra            (float, float)  [create]
            Angle to revolve horizontally and vertically.
        
        - verticalAngle : va             (float)         [create]
            Angle to revolve vertically.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.orbit`
        """
        pass
    def postProjectionMatrix(self):
        """
        Returns the post projection matrix used to compute film roll on the film back plane.
        
        Returns:
        'FloatMatrix'
        
        Derived from api method `maya.OpenMaya.MFnCamera.postProjectionMatrix`
        """
        pass
    def projectionMatrix(self):
        """
        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.
        
        Returns:
        'FloatMatrix'
        
        Derived from api method `maya.OpenMaya.MFnCamera.projectionMatrix`
        """
        pass
    def removeBookmark(self, bookmark): pass
    def rightDirection(self, space="'preTransform'"):
        """
        Returns the right direction vector for the camera.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.rightDirection`
        """
        pass
    def roll(self, degree, relative='True'):
        """
        The roll command rotates a camera about its viewing direction, a positive angle
        produces clockwise camera rotation, while a negative angle produces counter-
        clockwise camera rotation. The default mode is relative and the rotation is
        applied with respect to the current orientation of the camera. When mode is set
        to absolute, the rotation is applied with respect to the plane constructed from
        the following three vectors in the world space: the world up vector, the camera
        view vector, and the camera up vector. The rotation angle is specified in
        degrees. The roll command can be applied to either a perspective or an
        orthographic camera. This command may be applied to more than one camera;
        objects that are not cameras are ignored. When no camera name supplied, this
        command is applied to all currently active cameras.
        
        Flags:
        - absolute : abs                 (bool)          [create]
            Set to absolute mode.
        
        - degree : d                     (float)         [create]
            Set the amount of the rotation angle.
        
        - relative : rel                 (bool)          [create]
            Set to relative mode.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.roll`
        """
        pass
    def set(self, wsEyeLocation, wsViewDirection, wsUpDirection, horizFieldOfView, aspectRatio):
        """
        Convenience routine to set the camera viewing parameters. The specified values should be in world space where applicable.
        
        Parameters:
        wsEyeLocation : 'Point'
            Eye location to set in world space
        wsViewDirection : 'Vector'
            View direction to set in world space
        wsUpDirection : 'Vector'
            Up direction to set in world space
        horizFieldOfView : 'float'
            The horizontal field of view to set
        aspectRatio : 'float'
            The aspect ratio to set
        
        Derived from api method `maya.OpenMaya.MFnCamera.set`
        
        Aliases: set, setupCamera
        """
        pass
    def setAspectRatio(self, aspectRatio):
        """
        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.
        
        Parameters:
        aspectRatio : 'float'
            The aspect ratio to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setAspectRatio`
        """
        pass
    def setCameraScale(self, scale):
        """
        Sets the camera scale.
        
        Parameters:
        scale : 'float'
            The camera scale value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setCameraScale`
        """
        pass
    def setCenterOfInterest(self, dist):
        """
        Set the Center of Interest, which is defined to be a positive distance along the View Direction (i.e., "in front" of the Camera).
        
        Parameters:
        dist : 'float'
            center of interest distance value
        
        Derived from api method `maya.OpenMaya.MFnCamera.setCenterOfInterest`
        """
        pass
    def setCenterOfInterestPoint(self, centerOfInterest, space="'preTransform'"):
        """
        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.
        
        Parameters:
        centerOfInterest : 'Point'
            Center of interest point to be set
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setCenterOfInterestPoint`
        """
        pass
    def setClippingPlanes(self, ClippingPlanes):
        """
        Turn on/off manual setting of clip planes.
        
        Parameters:
        ClippingPlanes : 'bool'
            
        
        Derived from api method `maya.OpenMaya.MFnCamera.setClippingPlanes`
        """
        pass
    def setDepthOfField(self, depthOfField):
        """
        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.
        
        Parameters:
        depthOfField : 'bool'
            The depth of field value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setDepthOfField`
        """
        pass
    def setDisplayFieldChart(self, val='True', **kwargs):
        """
        Activate display of the video field chart when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setDisplayFilmGate(self, displayFilmGate):
        """
        Activate display of the film gate icons when looking through the camera.
        
        Parameters:
        displayFilmGate : 'bool'
            Specifies whether to display the film gate.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setDisplayFilmGate`
        """
        pass
    def setDisplayFilmOrigin(self, val='True', **kwargs):
        """
        Activate the display of the film origin guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setDisplayFilmPivot(self, val='True', **kwargs):
        """
        Activate display of the film pivot guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setDisplayGateMask(self, displayGateMask):
        """
        Activate shaded display of the film or resolution gate mask when looking through the camera. Does not activate the film or resolution gate display.
        
        Parameters:
        displayGateMask : 'bool'
            Specifies whether to display the film gate shaded.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setDisplayGateMask`
        """
        pass
    def setDisplayResolution(self, val='True', **kwargs):
        """
        Activate display of the current rendering resolution (as defined in the render globals) when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setDisplaySafeAction(self, val='True', **kwargs):
        """
        Activate display of the video Safe Action guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setDisplaySafeTitle(self, val='True', **kwargs):
        """
        Activate display of the video Safe Title guide when looking through the camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setEyePoint(self, eyeLocation, space="'preTransform'"):
        """
        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.
        
        Parameters:
        eyeLocation : 'Point'
            The eye location to set
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setEyePoint`
        """
        pass
    def setFStop(self, fStop):
        """
        Sets the f-stop value for the camera.
        
        Parameters:
        fStop : 'float'
            The F/Stop value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFStop`
        """
        pass
    def setFarClipPlane(self, dFar):
        """
        Set the distances to the Far Clipping Plane.
        
        Parameters:
        dFar : 'float'
            The far clipping plane value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFarClippingPlane`
        
        Aliases: setFarClipPlane, setFarClippingPlane
        """
        pass
    def setFarClippingPlane(self, dFar):
        """
        Set the distances to the Far Clipping Plane.
        
        Parameters:
        dFar : 'float'
            The far clipping plane value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFarClippingPlane`
        
        Aliases: setFarClipPlane, setFarClippingPlane
        """
        pass
    def setFarFocusDistance(self, farFocusDistance):
        """
        Set the farthest distance within the well-focus region
        
        Parameters:
        farFocusDistance : 'float'
            The far focus distance value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFarFocusDistance`
        """
        pass
    def setFilmFit(self, filmFit):
        """
        Sets how the digital image is to be fitted to the film back.
        
        Parameters:
        filmFit : 'Camera.FilmFit'
            The type of film fit
        
            values: 'fillFilmFit', 'horizontalFilmFit', 'verticalFilmFit', 'overscanFilmFit'
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFilmFit`
        """
        pass
    def setFilmFitOffset(self, filmFitOffset):
        """
        Set the film fit offset for the camera.
        
        Parameters:
        filmFitOffset : 'float'
            
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFilmFitOffset`
        """
        pass
    def setFilmRollOrder(self, filmRollOrder):
        """
        Assign the order in which the film back rotation is applied with respect to the pivot point.
        
        Parameters:
        filmRollOrder : 'Camera.RollOrder'
            The order to apply the film roll.
        
            values: 'rotateTranslate', 'translateRotate'
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFilmRollOrder`
        """
        pass
    def setFilmRollValue(self, filmRollValue):
        """
        Set the film roll value for film back.
        
        Parameters:
        filmRollValue : 'float'
            Specifies the amount rotation in the film back. The film back rotation value is specified in radians.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFilmRollValue`
        """
        pass
    def setFilmTranslateH(self, translate):
        """
        Set the horizontal film translate.
        
        Parameters:
        translate : 'float'
            The amount of translation normalized to the viewing area.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFilmTranslateH`
        """
        pass
    def setFilmTranslateV(self, translate):
        """
        Set the vertical film translate.
        
        Parameters:
        translate : 'float'
            The amount of translation normalized to the viewing area.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFilmTranslateV`
        """
        pass
    def setFocalLength(self, focalLength):
        """
        Sets the focal length for the camera.
        
        Parameters:
        focalLength : 'float'
            The focal length value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFocalLength`
        """
        pass
    def setFocusDistance(self, distance):
        """
        Set the focus at a certain distance in front of the camera.
        
        Parameters:
        distance : 'float'
            The focus distance to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setFocusDistance`
        """
        pass
    def setHomeCommand(self, val='True', **kwargs):
        """
        Specify the command to execute when viewSet -homeis applied to this camera. All occurances of %camerawill be replaced with the cameras name before viewSet runs the command.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setHorizontalFieldOfView(self, fov):
        """
        Sets the horizontal field of view for the camera.
        
        Parameters:
        fov : 'float'
            The horizontal field of view value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setHorizontalFieldOfView`
        """
        pass
    def setHorizontalFilmAperture(self, hFilmAperture):
        """
        Change the horizontal size of the camera aperture. Unit used is inches.
        
        Parameters:
        hFilmAperture : 'float'
            Horizontal file aperture value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setHorizontalFilmAperture`
        """
        pass
    def setHorizontalFilmOffset(self, hOffset):
        """
        Change the horizontal offset of the film. Unit used is inches.
        
        Parameters:
        hOffset : 'float'
            The horizontal film offset value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setHorizontalFilmOffset`
        """
        pass
    def setHorizontalPan(self, hPan):
        """
        Changes the camera 2D horizontal pan value. Unit is inches.
        
        Parameters:
        hPan : 'float'
            The camera 2D horizontal pan value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setHorizontalPan`
        """
        pass
    def setHorizontalRollPivot(self, horizontalRollPivot):
        """
        Set the horizontal roll pivot for film back roll.
        
        Parameters:
        horizontalRollPivot : 'float'
            Specifies the horizontal pivot value.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setHorizontalRollPivot`
        """
        pass
    def setHorizontalShake(self, hOffset):
        """
        Change the horizontal film-based camera shake value. Unit used is inches.
        
        Parameters:
        hOffset : 'float'
            The horizontal film-based camera shake value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setHorizontalShake`
        """
        pass
    def setJournalCommand(self, val='True', **kwargs):
        """
        Journal interactive camera commands. Commands can be undone when a camera is journaled.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setLensSqueezeRatio(self, aspectRatio):
        """
        Set the squeeze ratio of the lens. The aspect ratio is expressed as width/height.
        
        Parameters:
        aspectRatio : 'float'
            The lens squeeze ratio to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setLensSqueezeRatio`
        """
        pass
    def setLockTransform(self, val='True', **kwargs):
        """
        Lock the camera. When a camera is locked, its transformation information, that is, its Translate and Rotate properties cannot be adjusted, and the center of interest point cannot be moved. For orthographic cameras, Orthographic Width is also locked. For camera groups, Aim and Up locator's translate is also locked. For stereo cameras, the root camera is locked.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setMotionBlur(self, motionBlur):
        """
        Turns motion blur on/off for the camera.
        
        Parameters:
        motionBlur : 'bool'
            true turns motion blur on, false turns it off.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setMotionBlur`
        
        Aliases: setMotionBlur, setMotionBlurred
        """
        pass
    def setMotionBlurred(self, motionBlur):
        """
        Turns motion blur on/off for the camera.
        
        Parameters:
        motionBlur : 'bool'
            true turns motion blur on, false turns it off.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setMotionBlur`
        
        Aliases: setMotionBlur, setMotionBlurred
        """
        pass
    def setNearClipPlane(self, dNear):
        """
        Set the distances to the Near Clipping Plane.
        
        Parameters:
        dNear : 'float'
            The near clipping plane value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setNearClippingPlane`
        
        Aliases: setNearClipPlane, setNearClippingPlane
        """
        pass
    def setNearClippingPlane(self, dNear):
        """
        Set the distances to the Near Clipping Plane.
        
        Parameters:
        dNear : 'float'
            The near clipping plane value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setNearClippingPlane`
        
        Aliases: setNearClipPlane, setNearClippingPlane
        """
        pass
    def setNearFarClipPlanes(self, dNear, dFar):
        """
        Set the distances to the Near and Far Clipping Planes.
        
        Parameters:
        dNear : 'float'
            The near clipping plane value to be set
        dFar : 'float'
            The far clipping plane value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setNearFarClippingPlanes`
        """
        pass
    def setNearFarClippingPlanes(self, dNear, dFar):
        """
        Set the distances to the Near and Far Clipping Planes.
        
        Parameters:
        dNear : 'float'
            The near clipping plane value to be set
        dFar : 'float'
            The far clipping plane value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setNearFarClippingPlanes`
        """
        pass
    def setNearFocusDistance(self, nearFocusDistance):
        """
        Set the nearest distance within the well-focus region
        
        Parameters:
        nearFocusDistance : 'float'
            The near focus distance value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setNearFocusDistance`
        """
        pass
    def setOrtho(self, orthoState):
        """
        Switch the camera in and out of orthographic mode. This does not change the preset fov or the ortho width, presuming that these values are going to be set at the same time separately.
        
        Parameters:
        orthoState : 'bool'
            If true then the camera will be orthographic
        
        Derived from api method `maya.OpenMaya.MFnCamera.setIsOrtho`
        """
        pass
    def setOrthoWidth(self, orthoWidth):
        """
        Sets a new width for the ortho camera. Bad values are ignored.
        
        Parameters:
        orthoWidth : 'float'
            The ortho width value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setOrthoWidth`
        """
        pass
    def setOverscan(self, overscan):
        """
        Set the percent of overscan for this camera.
        
        Parameters:
        overscan : 'float'
            
        
        Derived from api method `maya.OpenMaya.MFnCamera.setOverscan`
        """
        pass
    def setPanZoomEnabled(self, enabled):
        """
        Changes the toggle value for the camera 2D pan/zoom enabled attribute.
        
        Parameters:
        enabled : 'bool'
            The camera 2D pan/zoom enabled toggle value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setPanZoomEnabled`
        """
        pass
    def setPostScale(self, sf):
        """
        Set the post scale value.
        
        Parameters:
        sf : 'float'
            The scaling factor.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setPostScale`
        """
        pass
    def setPreScale(self, sf):
        """
        Set the pre scale value.
        
        Parameters:
        sf : 'float'
            The scaling factor.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setPreScale`
        """
        pass
    def setRenderPanZoom(self, render):
        """
        Changes the toggle value for the camera render 2D pan/zoom enabled attribute.
        
        Parameters:
        render : 'bool'
            The camera render 2D pan/zoom toggle value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setRenderPanZoom`
        """
        pass
    def setShakeEnabled(self, enabled):
        """
        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.
        
        Parameters:
        enabled : 'bool'
            The film-based camera shake toggle value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setShakeEnabled`
        """
        pass
    def setShakeOverscan(self, overscan):
        """
        Changes the camera shake overscan value. Unit is a multiplier to the film aperture size. This attribute will affect the output render.
        
        Parameters:
        overscan : 'float'
            The camera shake overscan value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setShakeOverscan`
        """
        pass
    def setShakeOverscanEnabled(self, enabled):
        """
        Changes the toggle value for the camera shake overscan enabled attribute. If this attribute is false, the shakeOverscan value is ignored by the camera.
        
        Parameters:
        enabled : 'bool'
            The film-based camera shake overscan toggle value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setShakeOverscanEnabled`
        """
        pass
    def setShutterAngle(self, shutterAngle):
        """
        Change the current shutter angle which is one of the variables used to compute motion blur. The shutterAngle is specified in angular units.
        
        Parameters:
        shutterAngle : 'float'
            The shutter angle value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setShutterAngle`
        """
        pass
    def setStartupCamera(self, val='True', **kwargs):
        """
        A startup camera is marked undeletable and implicit. This flag can be used to set or query the startup state of a camera. There must always be at least one startup camera.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setStereoHIT(self, hit):
        """
        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.
        
        Parameters:
        hit : 'float'
            The stereo HIT value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setStereoHIT`
        """
        pass
    def setStereoHITEnabled(self, enabled):
        """
        Changes the toggle value for the stereo HIT enabled attribute. If this attribute is false, the stereoHIT value is ignored by the camera.
        
        Parameters:
        enabled : 'bool'
            The film-based camera stereo HIT toggle value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setStereoHITEnabled`
        """
        pass
    def setTumblePivot(self, point):
        """
        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).
        
        Parameters:
        point : 'Point'
            The tumble pivot location to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setTumblePivot`
        """
        pass
    def setUsePivotAsLocalSpace(self, how):
        """
        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.
        
        Parameters:
        how : 'bool'
            True to use local space tumbling for this camera, or false to use the current global tumble setting in Maya (the global tumble setting can be set via the Tumble Tool Option Box). The default value is false.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setUsePivotAsLocalSpace`
        """
        pass
    def setVerticalFieldOfView(self, fov):
        """
        Sets the vertical field of view for the camera.
        
        Parameters:
        fov : 'float'
            The vertical field of view value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setVerticalFieldOfView`
        """
        pass
    def setVerticalFilmAperture(self, vFilmAperture):
        """
        Change the vertical size of the camera aperture. Unit used is inches.
        
        Parameters:
        vFilmAperture : 'float'
            The vertical film aperture for the camera
        
        Derived from api method `maya.OpenMaya.MFnCamera.setVerticalFilmAperture`
        """
        pass
    def setVerticalFilmOffset(self, vOffset):
        """
        Change the vertical offset of the film. Unit used is inches.
        
        Parameters:
        vOffset : 'float'
            The vertical film offset value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setVerticalFilmOffset`
        """
        pass
    def setVerticalLock(self, lockFlag):
        """
        Sets the vertical lock to on or off for the camera.
        
        Parameters:
        lockFlag : 'bool'
            Vertical lock value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setVerticalLock`
        """
        pass
    def setVerticalPan(self, vPan):
        """
        Changes the camera 2D vertical pan value. Unit is inches.
        
        Parameters:
        vPan : 'float'
            The camera 2D vertical pan value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setVerticalPan`
        """
        pass
    def setVerticalRollPivot(self, verticalRollPivot):
        """
        Set the vertical roll pivot for film back roll.
        
        Parameters:
        verticalRollPivot : 'float'
            Specifies the vertical pivot value.
        
        Derived from api method `maya.OpenMaya.MFnCamera.setVerticalRollPivot`
        """
        pass
    def setVerticalShake(self, vOffset):
        """
        Changes the vertical film-based camera shake value. Unit used is inches.
        
        Parameters:
        vOffset : 'float'
            The vertical film-based camera shake value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setVerticalShake`
        """
        pass
    def setWorldCenterOfInterest(self, val='True', **kwargs):
        """
        Camera world center of interest point.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setWorldUp(self, val='True', **kwargs):
        """
        Camera world up vector.                  
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    def setZoom(self, zoom):
        """
        Changes the camera 2D zoom value.
        
        Parameters:
        zoom : 'float'
            The camera 2D zoom value to be set
        
        Derived from api method `maya.OpenMaya.MFnCamera.setZoom`
        """
        pass
    def setupCamera(self, wsEyeLocation, wsViewDirection, wsUpDirection, horizFieldOfView, aspectRatio):
        """
        Convenience routine to set the camera viewing parameters. The specified values should be in world space where applicable.
        
        Parameters:
        wsEyeLocation : 'Point'
            Eye location to set in world space
        wsViewDirection : 'Vector'
            View direction to set in world space
        wsUpDirection : 'Vector'
            Up direction to set in world space
        horizFieldOfView : 'float'
            The horizontal field of view to set
        aspectRatio : 'float'
            The aspect ratio to set
        
        Derived from api method `maya.OpenMaya.MFnCamera.set`
        
        Aliases: set, setupCamera
        """
        pass
    def track(*args, **kwargs):
        """
        The track command translates a camera horizontally or vertically in the world
        space. The viewing-direction and up-direction of the camera are not altered.
        There is no translation in the viewing direction. The track command can be
        applied to either a perspective or an orthographic camera. When no camera name
        is supplied, this command is applied to the camera in the active view.
        
        Flags:
        - down : d                       (float)         [create]
            Set the amount of down translation in unit distance.
        
        - left : l                       (float)         [create]
            Set the amount of left translation in unit distance.
        
        - right : r                      (float)         [create]
            Set the amount of right translation in unit distance.
        
        - upDistance01 : u               (float)         [create]
            Set the amount of up translation in unit distance. This is equivalent to using
            up/upDistance02 flag.
        
        - upDistance02 : up              (float)         [create]
            Set the amount of up translation in unit distance. This is equivalent to using
            u/upDistance01 flag.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.track`
        """
        pass
    def tumble(*args, **kwargs):
        """
        The tumble command revolves the camera(s) by varying the azimuth and elevation
        angles in the perspective window. When both the azimuth and the elevation angles
        are supplied on the command line, the camera is firstly tumbled for the azimuth
        angle, then tumbled for the elevation angle. When no camera name is supplied,
        this command is applied to the camera in the active view. The camera's rotate
        pivot will override a specified pivot point if the rotate pivot is not at the
        camera's eye point.
        
        Flags:
        - azimuthAngle : aa              (float)         [create]
            Degrees to change the azimuth angle.
        
        - elevationAngle : ea            (float)         [create]
            Degrees to change the elevation angle.
        
        - localTumble : lt               (int)           [create]
            Describes what point the camera will tumble around: 0 for the camera's tumble
            pivot, 1 for the camera's center of interest, and 2 for the camera's local axis,
            offset by its tumble pivot.
        
        - pivotPoint : pp                (float, float, float) [create]
            Three dimensional point used as the pivot point in the world space.
        
        - rotationAngles : ra            (float, float)  [create]
            Two values in degrees to change the azimuth and elevation angles.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.tumble`
        """
        pass
    def unnormalizedFarClippingPlane(self):
        """
        Returns the distance to the far clipping plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.unnormalizedFarClippingPlane`
        """
        pass
    def unnormalizedNearClippingPlane(self):
        """
        Returns the distance to the near clipping plane.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnCamera.unnormalizedNearClippingPlane`
        """
        pass
    def upDirection(self, space="'preTransform'"):
        """
        Returns the up direction vector for the camera.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.upDirection`
        """
        pass
    def updateBookmark(self, bookmark): pass
    def viewDirection(self, space="'preTransform'"):
        """
        Returns the view direction for the camera.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.viewDirection`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create, edit, or query a camera with the specified properties. The resulting
        camera can be repositioned using the viewPlace command. Many of the camera
        settings only affect the resulting rendered image. E.g. the F/Stop, shutter
        speed, the film related options, etc. Scaling the camera icon does not change
        any camera properties.
        
        Flags:
        - aspectRatio : ar               (float)         [create,query,edit]
            The ratio of the film back width to the film back height.
        
        - cameraScale : cs               (float)         [create,query,edit]
            Scale the camera.
        
        - centerOfInterest : coi         (float)         [create,query,edit]
            Set the linear distance from the camera's eye point to the center of interest.
        
        - clippingPlanes : cp            (bool)          [create,query,edit]
            Activate manual clipping planes.
        
        - depthOfField : dof             (bool)          [create,query,edit]
            Determines whether a depth of field calculation is performed to give varying
            focus depending on the distance of the objects.
        
        - displayFieldChart : dfc        (bool)          [create,query,edit]
            Activate display of the video field chart when looking through the camera.
        
        - displayFilmGate : dfg          (bool)          [create,query,edit]
            Activate display of the film gate icons when looking through the camera.
        
        - displayFilmOrigin : dfo        (bool)          [create,query,edit]
            Activate the display of the film origin guide when looking through the camera.
        
        - displayFilmPivot : dfp         (bool)          [create,query,edit]
            Activate display of the film pivot guide when looking through the camera.
        
        - displayGateMask : dgm          (bool)          [create,query,edit]
            Display the gate mask, file or resolution, as a shaded area to the edge of the
            viewport.
        
        - displayResolution : dr         (bool)          [create,query,edit]
            Activate display of the current rendering resolution (as defined in the render
            globals) when looking through the camera.
        
        - displaySafeAction : dsa        (bool)          [create,query,edit]
            Activate display of the video Safe Action guide when looking through the camera.
        
        - displaySafeTitle : dst         (bool)          [create,query,edit]
            Activate display of the video Safe Title guide when looking through the camera.
        
        - fStop : fs                     (float)         [create,query,edit]
            A real lens normally contains a diaphragm or other stop which blocks some of the
            light that would otherwise pass through it. This stop is usually approximately
            round, and its diameter as seen from the front of the lens is called the lens
            diameter. The lens diameter is often described by its relation to the focal
            length of the lens. A lens whose diameter is one-eighth its local length is said
            to have an F-stop of 8. This is an optical property of the lens.
        
        - farClipPlane : fcp             (float)         [create,query,edit]
            Specify the distance to the far clipping plane.
        
        - farFocusDistance : ffd         (float)         [create,query,edit]
            Linear distance to the far focus plane.
        
        - filmFit : ff                   (unicode)       [create,query,edit]
            This describes how the digital image (in pixels) relates to the film back. Since
            the film back is defined in terms of real numbers with some arbitrary film
            aspect, and the digital image is defined in integer pixels with an equally
            arbitrary (and different) resolution, relating the two can get complicated.
            There are 4 choices: horizontal In this case 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.verticalThis is 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.fillThis is a convenience item. The system calculates both horizontal and
            vertical fits and then applies the one that makes the digital image larger than
            the film back.overscanOverscanning 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.
        
        - filmFitOffset : ffo            (float)         [create,query,edit]
            Since we know from the above that the digital image may not match the film back
            exactly, we now have the question of how to position one relative to the other.
            Thus fit offset. Normally the centers are aligned. Fit offset lets you move the
            smaller image within the larger one. Specify the distance for film offset
            (inches).
        
        - filmRollOrder : fro            (unicode)       [create,query,edit]
            Specifies how the roll is applied with respect to the pivot value. Rotate-
            TranslateThe film back is first rotated then translated by the pivot point value
            .Translate-RotateThe film back is first translated then rotated by the film roll
            value.
        
        - filmRollValue : frv            (float)         [create,query,edit]
            This specifies that amount of rotation around the film back. The roll value is
            specified in degrees. The rotation occurs around the specified pivot point. This
            value is used to compute a film roll matrix, which is a component of the post-
            projection matrix.
        
        - filmTranslateH : fth           (float)         [create,query,edit]
            The horizontal film translation. Values are normalized to the viewing area.
        
        - filmTranslateV : ftv           (float)         [create,query,edit]
            The vertical film translation. Values are normalized to the viewing area.
        
        - focalLength : fl               (float)         [create,query,edit]
            This is the distance along the lens axis between the lens and the film plane
            when focal distanceis infinitely large. This is an optical property of the lens.
            This double precision parameter is always specified in millimeters.
        
        - focusDistance : fd             (float)         [create,query,edit]
            Set the focus at a certain distance in front of the camera.
        
        - homeCommand : hc               (unicode)       [create,query,edit]
            Specify the command to execute when viewSet -homeis applied to this camera. All
            occurances of %camerawill be replaced with the cameras name before viewSet runs
            the command.
        
        - horizontalFieldOfView : hfv    (float)         [create,query,edit]
            This is the film back width as seen by the lens when focused at infinity (ie.,
            focal length away) measured as an angle. Note that it has nothing to do with
            pixels or the digital image or any aspects. Angle of view is a derived field,
            that is, it is not used internally by Alias and can be completely determined
            from other information. It is included as a convenience for the user. Its
            derivation is aov = 2 \* atan( fbw / (2 \* f) ) where aovis the angle of view,
            fbwis the film back width and fis the focal length.
        
        - horizontalFilmAperture : hfa   (float)         [create,query,edit]
            The horizontal width of the camera's film plane. The camera's film is located on
            the film plane. The extent of the film which will be exposed to an image of the
            scene in front of the lens is limited to a rectangular area described by the
            film back. This double precision parameter is always specified in inches.
        
        - horizontalFilmOffset : hfo     (float)         [create,query,edit]
            Horizontal offset from the center of the film back. Normally the film back will
            be centered on the lens axis. However, this need not be so. Film offset is the
            displacement of the center of the film back from the lens axis, also measured in
            inches. Note that offsetting the film back will distort the image, but will not
            alter the focus. This double precision parameter is always specified in inches.
        
        - horizontalPan : hpn            (float)         [create,query,edit]
            Horizontal 2D camera pan (inches)
        
        - horizontalRollPivot : hrp      (float)         [create,query,edit]
            The horizontal pivot point from the center of the film back. The pivot point is
            used during rotation of the film back.  The pivot is the point where the
            rotation occurs around. This double precision parameter corresponds to the
            normalized viewport. This value is a part of the post projection matrix.
        
        - horizontalShake : hs           (float)         [create,query,edit]
            Another horizontal offset from the center of the film back, which can be used
            and stored on the camera in addition to the horizonal film offset attribute.
            This allows for film-based camera shake internal to the camera.  This works in
            exactly the same units and coordinates that the film offset attribute does. The
            effect of this attribute is toggled by the shake enabled attribute.
        
        - journalCommand : jc            (bool)          [create,query,edit]
            Journal interactive camera commands. Commands can be undone when a camera is
            journaled.
        
        - lensSqueezeRatio : lsr         (float)         [create,query,edit]
            This is presently just an information field in the camera editor is meant to
            convey the horizontal distortion of the anamorphic lens normally used with some
            film formats. If it were used, it would do something like pixel aspect. Remember
            however that lens distortion (intentional or not) is slightly different than the
            output hardware's quantization. The fact that a netdistortion parameter could be
            used for both may or may not confuse the issue.
        
        - lockTransform : lt             (bool)          [create,query,edit]
            Lock the camera. When a camera is locked, its transformation information, that
            is, its Translate and Rotate properties cannot be adjusted, and the center of
            interest point cannot be moved. For orthographic cameras, Orthographic Width is
            also locked. For camera groups, Aim and Up locator's translate is also locked.
            For stereo cameras, the root camera is locked.
        
        - motionBlur : mb                (bool)          [create,query,edit]
            Determines whether the camera's image is motion blured (as opposed to an
            object's image). For example, if you want to blur the camera movement when you
            are performing a flyby.
        
        - name : n                       (unicode)       [create,query,edit]
            Name of the camera.
        
        - nearClipPlane : ncp            (float)         [create,query,edit]
            Specify the distance to the NEAR clipping plane.
        
        - nearFocusDistance : nfd        (float)         [create,query,edit]
            Linear distance to the near focus plane.
        
        - orthographic : o               (bool)          [create,query,edit]
            Activate the orthographic camera.
        
        - orthographicWidth : ow         (float)         [create,query,edit]
            Set the orthographic projection width.
        
        - overscan : ovr                 (float)         [create,query,edit]
            Set the percent of overscan.
        
        - panZoomEnabled : pze           (bool)          [create,query,edit]
            Toggle camera 2D pan and zoom
        
        - position : p                   (float, float, float) [create,query,edit]
            Three linear values can be specified to translate the camera.
        
        - postScale : pts                (float)         [create,query,edit]
            The post-scale value.  This value multiplied against the computed projection
            matrix. It is applied after the the film roll.
        
        - preScale : prs                 (float)         [create,query,edit]
            The pre-scale value. The value is multiplied against the computed projection
            matrix. It is applied before the film roll.
        
        - renderPanZoom : rpz            (bool)          [create,query,edit]
            Toggle camera 2D pan and zoom in render
        
        - rotation : rot                 (float, float, float) [create,query,edit]
            Three angular values can be specified to rotate the camera.
        
        - shakeEnabled : se              (bool)          [create,query,edit]
            Toggles the effect of the horizontal and vertical shake attributes.
        
        - shakeOverscan : so             (float)         [create,query,edit]
            Controls the amount of overscan in the output rendered image. For use when
            adding film-based camera shake.  Acts as a multiplier to the film aperture on
            the camera.
        
        - shakeOverscanEnabled : soe     (bool)          [create,query,edit]
            Toggles the effect of the shake overscan attribute.
        
        - shutterAngle : sa              (float)         [create,query,edit]
            Specify the shutter angle (degrees).
        
        - startupCamera : sc             (bool)          [create,query,edit]
            A startup camera is marked undeletable and implicit. This flag can be used to
            set or query the startup state of a camera. There must always be at least one
            startup camera.
        
        - stereoHorizontalImageTranslate : hit (float)         [create,query,edit]
            A film-back offset for use in stereo camera rigs.
        
        - stereoHorizontalImageTranslateEnabled : she (bool)          [create,query,edit]
            Toggles the effect of the stereo HIT attribute.
        
        - verticalFieldOfView : vfv      (float)         [create,query,edit]
            Set the vertical field of view.
        
        - verticalFilmAperture : vfa     (float)         [create,query,edit]
            The vertical height of the camera's film plane. This double precision parameter
            is always specified in inches.
        
        - verticalFilmOffset : vfo       (float)         [create,query,edit]
            Vertical offset from the center of the film back. This double precision
            parameter is always specified in inches.
        
        - verticalLock : vl              (bool)          [create,query,edit]
            Lock the size of the vertical film aperture.
        
        - verticalPan : vpn              (float)         [create,query,edit]
            Vertical 2D camera pan (inches)
        
        - verticalRollPivot : vrp        (float)         [create,query,edit]
            Vertical pivot point used for rotating the film back. This double precision
            parameter corresponds to the normalized viewport. This value is used to compute
            the film roll matrix, which is a component of the post projection matrix.
        
        - verticalShake : vs             (float)         [create,query,edit]
            Vertical offset from the center of the film back.  See horizontal shake
            attribute description.  This is toggled by the shake enabled attribute.
        
        - worldCenterOfInterest : wci    (float, float, float) [create,query,edit]
            Camera world center of interest point.
        
        - worldUp : wup                  (float, float, float) [create,query,edit]
            Camera world up vector.
        
        - zoom : zom                     (float)         [create,query,edit]
            The percent over the film viewable frustum to display                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.camera`
        """
        pass
    FilmFit = {}
    
    
    RollOrder = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Light(Shape):
    def getCenterOfIllumination(self):
        """
        Retrieves the value of the "centerOfIllumination" attribute of a light node. This attribute represents the distance to the center of illumination of the light.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnLight.centerOfIllumination`
        """
        pass
    def getColor(self):
        """
        Retrieves the value of the "color" attribute of a light node. This attribute represents the color of the light emitted by the light node.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLight.color`
        """
        pass
    def getIntensity(self):
        """
        Retrieves the value of the "intensity" attribute of a light node. This attribute represents a uniform scaling factor applied to the light color.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnLight.intensity`
        """
        pass
    def getNumShadowSamples(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnLight.numShadowSamples`
        """
        pass
    def getOpticalFXvisibility(self):
        """
        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.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLight.opticalFXvisibility`
        """
        pass
    def getRayDepthLimit(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnLight.rayDepthLimit`
        """
        pass
    def getShadowColor(self):
        """
        Retrieves the value of the "shadowColor" attribute of a light node. This attribute represents the color of the shadows cast by the light.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLight.shadowColor`
        """
        pass
    def getUseRayTraceShadows(self):
        """
        Retrieves the value of the "useRayTraceShadows" attribute of a light node. This attribute determines whether or not the light should raytrace it's shadows.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnLight.useRayTraceShadows`
        """
        pass
    def lightAmbient(self):
        """
        Retrieves the value of the "lightAmbient" attribute of a light node. This attribute indicates if the light has an ambient component.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnLight.lightAmbient`
        """
        pass
    def lightDiffuse(self):
        """
        Retrieves the value of the "lightDiffuse" attribute of a light node. This attribute indicates if the light has a diffuse component.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnLight.lightDiffuse`
        """
        pass
    def lightDirection(self, instance, space="'world'"):
        """
        Returns the direction in which the light is pointing. This is only valid for lights which are associated with a direction, such as area, directional or spot lights. The vector returned is not normalized.
        
        Parameters:
        instance : 'int'
            The instance of the light for which to return the direction.
        space : 'Space.Space'
            The coordinate space for which the direction vector is returned. If MSpace::kWorld is passed in the vector will be in the lights world space. If any other MSpace::Space value in pass in the vector will be returned in object (or local) space.
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'FloatVector'
        
        Derived from api method `maya.OpenMaya.MSpace.lightDirection`
        """
        pass
    def lightIntensity(self):
        """
        Retrieves the value of the "lightIntensity" attribute of a light node. This attribute represents the intensity of the light specified as a color.
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnLight.lightIntensity`
        """
        pass
    def lightSpecular(self):
        """
        Retrieves the value of the "lightSpecular" attribute of a light node. This attribute indicates if the light has a specular component.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnLight.lightSpecular`
        """
        pass
    def setCenterOfIllumination(self, dist):
        """
        Sets the value of the "centerOfIllumination" attribute of a light node.
        
        Parameters:
        dist : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setCenterOfIllumination`
        """
        pass
    def setColor(self, col):
        """
        Sets the value of the "color" attribute of a light node.
        
        Parameters:
        col : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setColor`
        """
        pass
    def setIntensity(self, intens):
        """
        Sets the value of the "intensity" attribute of a light node.
        
        Parameters:
        intens : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setIntensity`
        """
        pass
    def setNumShadowSamples(self, num_shadow_samples):
        """
        Sets the value of the "numShadowSamples" attribute of a light node.
        
        Parameters:
        num_shadow_samples : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setNumShadowSamples`
        """
        pass
    def setOpticalFXvisibility(self, visibility):
        """
        Sets the value of the "opticalFXvisibility" attribute of a light node.
        
        Parameters:
        visibility : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setOpticalFXvisibility`
        """
        pass
    def setRayDepthLimit(self, ray_depth_limit):
        """
        Sets the value of the "rayDepthLimit" attribute of a light node.
        
        Parameters:
        ray_depth_limit : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setRayDepthLimit`
        """
        pass
    def setShadowColor(self, shadow_color):
        """
        Sets the value of the "shadowColor" attribute of a light node.
        
        Parameters:
        shadow_color : 'Color'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setShadowColor`
        """
        pass
    def setUseRayTraceShadows(self, useRayTraceShadows):
        """
        Sets the value of the "useRayTraceShadows" attribute of a light node.
        
        Parameters:
        useRayTraceShadows : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnLight.setUseRayTraceShadows`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HairConstraint(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class TextureDeformerHandle(Transform):
    __melnode__ = []
    
    
    __readonly__ = {}


class DimensionShape(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyCBoolOp(PolyBoolOp):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getClassification(self, **kwargs):
        """
        Changes how intersections of open and closed manifolds are treated. 1 for Edge, 2 for Normal.                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getFaceAreaThreshold(self, **kwargs):
        """
        Area threshold to determine whether faces should be collapsed before boolean. Attribute is ignored unless useThresholds is set to true Default:0.0001                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getMergeUVSets(self, **kwargs):
        """
        Specify how UV sets will be merged on the output mesh. 0 = No Merge: Each UV set on each mesh will become a new UV set in the output.1 = Merge By Name: UV sets with the same name will be merged.2 = Merge By UV Links: UV sets will be merged so that UV linking on the input meshes continues to work.The default is merge by name.                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getOperation(self, **kwargs):
        """
        Boolean operation type. 1=union, 2=difference, 3=intersection. Default type is union. Default:kBoolOpUnion                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getPreserveColor(self, **kwargs):
        """
        If true, boolean op will compute color for the new mesh. If false, the new mesh won't have any color set. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getUseCarveBooleans(self, **kwargs):
        """
        If true, use the Carve Boolean library                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getUseThresholds(self, **kwargs):
        """
        If true, merge vertices with separations less then vertexDistanceThreshold and collapse faces with areas less then faceAreaThreshold. If false, do not merge vertices or collapse faces Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def getVertexDistanceThreshold(self, **kwargs):
        """
        Tolerance to determine whether vertices (and edges) should be merged before boolean operation is applied. Attribute is ignored unless useThresholds is set to true Default:0.001                  Flags From polyUnite Node
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setClassification(self, val='True', **kwargs):
        """
        Changes how intersections of open and closed manifolds are treated. 1 for Edge, 2 for Normal.                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setFaceAreaThreshold(self, val='True', **kwargs):
        """
        Area threshold to determine whether faces should be collapsed before boolean. Attribute is ignored unless useThresholds is set to true Default:0.0001                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setMergeUVSets(self, val='True', **kwargs):
        """
        Specify how UV sets will be merged on the output mesh. 0 = No Merge: Each UV set on each mesh will become a new UV set in the output.1 = Merge By Name: UV sets with the same name will be merged.2 = Merge By UV Links: UV sets will be merged so that UV linking on the input meshes continues to work.The default is merge by name.                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setOperation(self, val='True', **kwargs):
        """
        Boolean operation type. 1=union, 2=difference, 3=intersection. Default type is union. Default:kBoolOpUnion                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setPreserveColor(self, val='True', **kwargs):
        """
        If true, boolean op will compute color for the new mesh. If false, the new mesh won't have any color set. Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setUseCarveBooleans(self, val='True', **kwargs):
        """
        If true, use the Carve Boolean library                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setUseThresholds(self, val='True', **kwargs):
        """
        If true, merge vertices with separations less then vertexDistanceThreshold and collapse faces with areas less then faceAreaThreshold. If false, do not merge vertices or collapse faces Default:false                  
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    def setVertexDistanceThreshold(self, val='True', **kwargs):
        """
        Tolerance to determine whether vertices (and edges) should be merged before boolean operation is applied. Attribute is ignored unless useThresholds is set to true Default:0.001                  Flags From polyUnite Node
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a new poly as the result of a boolean operation on input
        polys : union, intersection, difference. Only for difference, the order of the
        selected objects is important : result = object1 - object2. If no objects are
        specified in the command line, then the objects from the active list are used.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - classification : cls           (int)           [create,query,edit]
            Changes how intersections of open and closed manifolds are treated. 1 for Edge,
            2 for Normal.
        
        - constructionHistory : ch       (bool)          []
        
        - edgeInterpolation : eit        (bool)          []
        
        - faceAreaThreshold : fat        (float)         [create,query,edit]
            Area threshold to determine whether faces should be collapsed before boolean.
            Attribute is ignored unless useThresholds is set to true Default:0.0001
        
        - frozen : fzn                   (bool)          []
        
        - mergeUVSets : muv              (int)           [create,query,edit]
            Specify how UV sets will be merged on the output mesh. 0 = No Merge: Each UV set
            on each mesh will become a new UV set in the output.1 = Merge By Name: UV sets
            with the same name will be merged.2 = Merge By UV Links: UV sets will be merged
            so that UV linking on the input meshes continues to work.The default is merge by
            name.
        
        - name : n                       (unicode)       []
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        - object : o                     (bool)          []
        
        - operation : op                 (int)           [create,query,edit]
            Boolean operation type. 1=union, 2=difference, 3=intersection. Default type is
            union. Default:kBoolOpUnion
        
        - planarTolerance : ptl          (float)         []
        
        - preserveColor : pcr            (bool)          [create,query,edit]
            If true, boolean op will compute color for the new mesh. If false, the new mesh
            won't have any color set. Default:false
        
        - sortOutput : sop               (bool)          []
        
        - useCarveBooleans : ucb         (bool)          [create,query,edit]
            If true, use the Carve Boolean library
        
        - useThresholds : uth            (bool)          [create,query,edit]
            If true, merge vertices with separations less then vertexDistanceThreshold and
            collapse faces with areas less then faceAreaThreshold. If false, do not merge
            vertices or collapse faces Default:false
        
        - vertexDistanceThreshold : vdt  (float)         [create,query,edit]
            Tolerance to determine whether vertices (and edges) should be merged before
            boolean operation is applied. Attribute is ignored unless useThresholds is set
            to true Default:0.001                  Flags From polyUnite Node
        
        
        Derived from mel command `maya.cmds.polyCBoolOp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdLayoutUV(SubdModifierUV):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getFlipReversed(self, **kwargs):
        """
        If this flag is turned on, the reversed UV pieces are fliped.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getLayout(self, **kwargs):
        """
        How to move the UV pieces, after cuts are applied: 0 No move is applied. 1 Layout the pieces along the U axis. 2 Layout the pieces in a square shape.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getLayoutMethod(self, **kwargs):
        """
        Which layout method to use: 0 Block Stacking. 1 Shape Stacking.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getPercentageSpace(self, **kwargs):
        """
        When layout is set to square, this value is a percentage of the texture area which is added around each UV piece. It can be used to ensure each UV piece uses different pixels in the texture. Maximum value is 5 percent.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getRotateForBestFit(self, **kwargs):
        """
        0 No rotation is applied. 1 Only allow 90 degree rotations. 2 Allow free rotations.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getScale(self, **kwargs):
        """
        How to scale the pieces, after move and cuts: 0 No scale is applied. 1 Uniform scale to fit in unit square. 2 Non proportional scale to fit in unit square.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getSeparate(self, **kwargs):
        """
        Which UV edges should be cut: 0 No cuts. 1 Cut only along folds. 2 Make all necessary cuts to avoid all intersections.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        If true, performs the operation in world space coordinates as opposed to local space.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setFlipReversed(self, val='True', **kwargs):
        """
        If this flag is turned on, the reversed UV pieces are fliped.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setLayout(self, val='True', **kwargs):
        """
        How to move the UV pieces, after cuts are applied: 0 No move is applied. 1 Layout the pieces along the U axis. 2 Layout the pieces in a square shape.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setLayoutMethod(self, val='True', **kwargs):
        """
        Which layout method to use: 0 Block Stacking. 1 Shape Stacking.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  Common flags
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setPercentageSpace(self, val='True', **kwargs):
        """
        When layout is set to square, this value is a percentage of the texture area which is added around each UV piece. It can be used to ensure each UV piece uses different pixels in the texture. Maximum value is 5 percent.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setRotateForBestFit(self, val='True', **kwargs):
        """
        0 No rotation is applied. 1 Only allow 90 degree rotations. 2 Allow free rotations.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        How to scale the pieces, after move and cuts: 0 No scale is applied. 1 Uniform scale to fit in unit square. 2 Non proportional scale to fit in unit square.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setSeparate(self, val='True', **kwargs):
        """
        Which UV edges should be cut: 0 No cuts. 1 Cut only along folds. 2 Make all necessary cuts to avoid all intersections.                  
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        If true, performs the operation in world space coordinates as opposed to local space.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Move UVs in the texture plane to avoid overlaps.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create]
            Turn the construction history on or off.
        
        - flipReversed : fr              (bool)          [create,query,edit]
            If this flag is turned on, the reversed UV pieces are fliped.
        
        - frozen : fzn                   (bool)          []
        
        - layout : l                     (int)           [create,query,edit]
            How to move the UV pieces, after cuts are applied: 0 No move is applied. 1
            Layout the pieces along the U axis. 2 Layout the pieces in a square shape.
        
        - layoutMethod : lm              (int)           [create,query,edit]
            Which layout method to use: 0 Block Stacking. 1 Shape Stacking.
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal                  Common flags
        
        - percentageSpace : ps           (float)         [create,query,edit]
            When layout is set to square, this value is a percentage of the texture area
            which is added around each UV piece. It can be used to ensure each UV piece uses
            different pixels in the texture. Maximum value is 5 percent.
        
        - rotateForBestFit : rbf         (int)           [create,query,edit]
            0 No rotation is applied. 1 Only allow 90 degree rotations. 2 Allow free
            rotations.
        
        - scale : sc                     (int)           [create,query,edit]
            How to scale the pieces, after move and cuts: 0 No scale is applied. 1 Uniform
            scale to fit in unit square. 2 Non proportional scale to fit in unit square.
        
        - separate : se                  (int)           [create,query,edit]
            Which UV edges should be cut: 0 No cuts. 1 Cut only along folds. 2 Make all
            necessary cuts to avoid all intersections.
        
        - worldSpace : ws                (bool)          [create,query,edit]
            If true, performs the operation in world space coordinates as opposed to local
            space.                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.subdLayoutUV`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Follicle(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class FlexorShape(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class HairSystem(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class Joint(Transform):
    def assumePreferredAngles(self, val='True', **kwargs):
        """
        Meaningful only in the edit mode. It sets the joint angles to the corresponding preferred angles.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def children(self, val='True', **kwargs):
        """
        It tells the command to apply all the edit options not only to the selected joints, but also to their descendent joints in the DAG.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def component(self, val='True', **kwargs):
        """
        Use with the -position switch to position the joint relative to its parent (like -relative) but to compute new positions for all children joints so their world coordinate positions do not change.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def connect(*args, **kwargs):
        """
        This command will connect two skeletons based on the two selected joints. The
        first selected joint can be made a child of the parent of the second selected
        joint or a child of the second selected joint, depending on the flags used.
        Note1: The first selected joint must be the root of a skeleton. The second
        selected joint must have a parent. Note2: If a joint name is specified in the
        command line, it is used as the child and the first selected joint will be the
        parent. If no joint name is given at the command line, two joints must be
        selected.
        
        Flags:
        - connectMode : cm               (bool)          [create]
            The first selected joint will be parented under the parent of the second
            selected joint.
        
        - parentMode : pm                (bool)          [create]
            The first selected joint will be parented under the second selected joint. Both
            joints will be in the active list(selection list).                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.connectJoint`
        """
        pass
    def disconnect(*args, **kwargs):
        """
        This command will break a skeleton at the selected joint and delete any
        associated handles.
        
        Flags:
        - attachHandleMode : ahm         (bool)          [create]
            This flag is obsolete and no longer supported.
        
        - deleteHandleMode : dhm         (bool)          [create]
            Delete the handle on the associated joint.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.disconnectJoint`
        """
        pass
    def getAngleX(self, **kwargs):
        """
        Set the x-axis angle. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getAngleY(self, **kwargs):
        """
        Set the y-axis angle. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getAngleZ(self, **kwargs):
        """
        Set the z-axis angle. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getDegreeOfFreedom(self, **kwargs):
        """
        Specifies the degrees of freedom for the IK. Valid strings consist of non-duplicate letters from x, y, and z. The letters in the string indicate what rotations are to be used by IK. The order a letter appear in the string does not matter. Examples are x, yz, xyz. When queried, this flag returns a string. Modifying dof will change the locking state of the corresponding rotation attributes. The rule is: if an rotation is turned into a dof, it will be unlocked if it is currently locked. When it is turned into a non-dof, it will be locked if it is not currently locked.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getDegreesOfFreedom(self):
        """
        Get degrees of freedom of this joint
        
        Returns:
        Tuple['bool', 'bool', 'bool']
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.getDegreesOfFreedom`
        """
        pass
    def getExists(self, **kwargs):
        """
        Does the named joint exist? When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getLimitSwitchX(self, **kwargs):
        """
        Use the limit the x-axis rotation? When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getLimitSwitchY(self, **kwargs):
        """
        Use the limit the y-axis rotation? When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getLimitSwitchZ(self, **kwargs):
        """
        Use the Limit the z-axis rotation? When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getLimitX(self, **kwargs):
        """
        Set lower and upper limits on the x-axis of rotation.  Also turns on the joint limit. When queried, this flag returns 2 floats.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getLimitY(self, **kwargs):
        """
        Set lower and upper limits on the y-axis of rotation.  Also turns on the joint limit. When queried, this flag returns 2 floats.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getLimitZ(self, **kwargs):
        """
        Set lower and upper limits on the z-axis of rotation.  Also turns on the joint limit. When queried, this flag returns 2 floats.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getMaxRotateDampXRange(self):
        """
        Get the maximum of the damping range in X. This corresponds to the maxRotateDampXRange attribute on the joint.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.maxRotateDampXRange`
        """
        pass
    def getMaxRotateDampXStrength(self):
        """
        Get the minimum of the damping strength in X.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.maxRotateDampXStrength`
        """
        pass
    def getMaxRotateDampYRange(self):
        """
        Get the maximum of the damping range in Y. This corresponds to the maxRotateDampYRange attribute on the joint.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.maxRotateDampYRange`
        """
        pass
    def getMaxRotateDampYStrength(self):
        """
        Get the minimum of the damping strength in X.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.maxRotateDampYStrength`
        """
        pass
    def getMaxRotateDampZRange(self):
        """
        Get the maximum of the damping range in Z. This corresponds to the maxRotateDampZRange attribute on the joint.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.maxRotateDampZRange`
        """
        pass
    def getMaxRotateDampZStrength(self):
        """
        Get the minimum of the damping strength in X.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.maxRotateDampZStrength`
        """
        pass
    def getMinRotateDampXRange(self):
        """
        Get the minimum of the damping range in X. This corresponds to the minRotateDampXRange attribute on the joint.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.minRotateDampXRange`
        """
        pass
    def getMinRotateDampXStrength(self):
        """
        Get the minimum of the damping strength in X.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.minRotateDampXStrength`
        """
        pass
    def getMinRotateDampYRange(self):
        """
        Get the minimum of the damping range in Y. This corresponds to the minRotateDampYRange attribute on the joint.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.minRotateDampYRange`
        """
        pass
    def getMinRotateDampYStrength(self):
        """
        Get the minimum of the damping strength in X.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.minRotateDampYStrength`
        """
        pass
    def getMinRotateDampZRange(self):
        """
        Get the minimum of the damping range in Z. This corresponds to the minRotateDampZRange attribute on the joint.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.minRotateDampZRange`
        """
        pass
    def getMinRotateDampZStrength(self):
        """
        Get the minimum of the damping strength in X.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.minRotateDampZStrength`
        """
        pass
    def getOrientation(self):
        """
        Get the joint orientation. This corresponds to the jointOrient attribute on the joint, which is stored internally as a quaternion. It is different from the rotation orientation defined in the transform node. Modifying the jointOrient changes the coordinate axes, which affects how scaling a joint behaves.
        
        Returns:
        'Quaternion'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.getOrientation`
        """
        pass
    def getPreferedAngle(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    def getPreferredAngle(self):
        """
        Get the preferred orientation for this joint (in XYZ order)
        
        Returns:
        ('float', 'float', 'float')
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.getPreferredAngle`
        """
        pass
    def getRadius(self, **kwargs):
        """
        Specifies the joint radius.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getScaleCompensate(self, **kwargs):
        """
        It sets the scaleCompenstate attribute of the joint to the given argument. When this is true, the scale of the parent joint will be compensated before any rotation of this joint is applied, so that the bone to the joint is scaled but not the bones to its child joints. When queried, this flag returns an boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getScaleOrientation(self):
        """
        Get the orientation of the coordinate axes for rotation. This is equivalent to calling the MFnTransform::rotateOrientation method, and corresponds to the rotateAxis attribute on the joint node.
        
        Returns:
        'Quaternion'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.getScaleOrientation`
        """
        pass
    def getSegmentScale(self):
        """
        Get the local space scale values for the joint segment (bone). This is equivalent to calling MFnTransform::getScale.
        
        Returns:
        ('float', 'float', 'float')
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.getSegmentScale`
        """
        pass
    def getStiffness(self):
        """
        Get the stiffness (from 0 to 100.0) for the joint. The stiffness attribute is used by ik solvers to generate a resistance to a joint motion. The higher the stiffness the less it will rotate. Stiffness works in relative sense: it determines the willingness of this joint to rotate with respect to the other joint in the ik chain.
        
        Returns:
        ('float', 'float', 'float')
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.getStiffness`
        """
        pass
    def getStiffnessX(self, **kwargs):
        """
        Set the stiffness (from 0 to 100.0) for x-axis. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getStiffnessY(self, **kwargs):
        """
        Set the stiffness (from 0 to 100.0) for y-axis. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def getStiffnessZ(self, **kwargs):
        """
        Set the stiffness (from 0 to 100.0) for z-axis. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def hikJointName(self):
        """
        Get the name that the HumanIK solver uses to identify this joint.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.hikJointName`
        """
        pass
    def insert(*args, **kwargs):
        """
        This command will insert a new joint under the given or selected joint. If the
        given joint has child joints, they will be reparented under the new inserted
        joint. The given joint(or selected joint) should not have skin attached. The
        command works on the selected joint. No options or flags are necessary.
        
        
        Derived from mel command `maya.cmds.insertJoint`
        """
        pass
    def orientJoint(self, val='True', **kwargs):
        """
        The argument can be one of the following strings: xyz, yzx, zxy, zyx, yxz, xzy, none. It modifies the joint orientation and scale orientation so that the axis indicated by the first letter in the argument will be aligned with the vector from this joint to its first child joint. For example, if the argument is xyz, the x-axis will point towards the child joint. The alignment of the remaining two joint orient axes are dependent on whether or not the -sao/-secondaryAxisOrient flag is used. If the -sao flag is used, see the documentation for that flag for how the remaining axes are aligned. In the absence of a user specification for the secondary axis orientation, the rotation axis indicated by the last letter in the argument will be aligned with the vector perpendicular to first axis and the vector from this joint to its parent joint. The remaining axis is aligned according the right hand rule. If the argument is none, the joint orientation will be set to zero and its effect to the hierarchy below will be offset by modifying the scale orientation. The flag will be ignored if: A. the joint has non-zero rotations when the argument is not none. B. the joint does not have child joint, or the distance to the child joint is zero when the argument is not none. C. either flag -o or -so is set.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def secondaryAxisOrient(self, val='True', **kwargs):
        """
        The argument can be one of the following strings: xup, xdown, yup, ydown, zup, zdown, none. This flag is used in conjunction with the -oj/orientJoint flag. It specifies the scene axis that the second axis should align with. For example, a flag combination of -oj yzx -sao yupwould result in the y-axis pointing down the bone, the z-axis oriented with the scene's positive y-axis, and the x-axis oriented according to the right hand rule.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setAngleX(self, val='True', **kwargs):
        """
        Set the x-axis angle. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setAngleY(self, val='True', **kwargs):
        """
        Set the y-axis angle. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setAngleZ(self, val='True', **kwargs):
        """
        Set the z-axis angle. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setDegreeOfFreedom(self, val='True', **kwargs):
        """
        Specifies the degrees of freedom for the IK. Valid strings consist of non-duplicate letters from x, y, and z. The letters in the string indicate what rotations are to be used by IK. The order a letter appear in the string does not matter. Examples are x, yz, xyz. When queried, this flag returns a string. Modifying dof will change the locking state of the corresponding rotation attributes. The rule is: if an rotation is turned into a dof, it will be unlocked if it is currently locked. When it is turned into a non-dof, it will be locked if it is not currently locked.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setDegreesOfFreedom(self, freeInX, freeInY, freeInZ):
        """
        Set the degrees of freedom of this joint by specifying which axes are allowed to rotate.
        
        Parameters:
        freeInX : 'bool'
            the first degree of freedom
        freeInY : 'bool'
            the second degree of freedom
        freeInZ : 'bool'
            the third degree of freedom
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setDegreesOfFreedom`
        """
        pass
    def setLimitSwitchX(self, val='True', **kwargs):
        """
        Use the limit the x-axis rotation? When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setLimitSwitchY(self, val='True', **kwargs):
        """
        Use the limit the y-axis rotation? When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setLimitSwitchZ(self, val='True', **kwargs):
        """
        Use the Limit the z-axis rotation? When queried, this flag returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setLimitX(self, val='True', **kwargs):
        """
        Set lower and upper limits on the x-axis of rotation.  Also turns on the joint limit. When queried, this flag returns 2 floats.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setLimitY(self, val='True', **kwargs):
        """
        Set lower and upper limits on the y-axis of rotation.  Also turns on the joint limit. When queried, this flag returns 2 floats.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setLimitZ(self, val='True', **kwargs):
        """
        Set lower and upper limits on the z-axis of rotation.  Also turns on the joint limit. When queried, this flag returns 2 floats.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setMaxRotateDampXRange(self, angle):
        """
        Set the maximum of the damping range in X
        
        Parameters:
        angle : 'float'
            the damping range to set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMaxRotateDampXRange`
        """
        pass
    def setMaxRotateDampXStrength(self, angle):
        """
        Set the maximum of the damping strength in X.
        
        Parameters:
        angle : 'float'
            The new damping strength value
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMaxRotateDampXStrength`
        """
        pass
    def setMaxRotateDampYRange(self, angle):
        """
        Set the maximum of the damping range in Y
        
        Parameters:
        angle : 'float'
            the damping range to set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMaxRotateDampYRange`
        """
        pass
    def setMaxRotateDampYStrength(self, angle):
        """
        Set the maximum of the damping strength in Y.
        
        Parameters:
        angle : 'float'
            The new damping strength value
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMaxRotateDampYStrength`
        """
        pass
    def setMaxRotateDampZRange(self, angle):
        """
        Set the maximum of the damping range in Z
        
        Parameters:
        angle : 'float'
            the damping range to set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMaxRotateDampZRange`
        """
        pass
    def setMaxRotateDampZStrength(self, angle):
        """
        Set the maximum of the damping strength in Z.
        
        Parameters:
        angle : 'float'
            The new damping strength value
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMaxRotateDampZStrength`
        """
        pass
    def setMinRotateDampXRange(self, angle):
        """
        Set the minimum of the damping range in X
        
        Parameters:
        angle : 'float'
            The damping range to set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMinRotateDampXRange`
        """
        pass
    def setMinRotateDampXStrength(self, angle):
        """
        Set the maximum of the damping strength in Z.
        
        Parameters:
        angle : 'float'
            The new damping strength value
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMinRotateDampXStrength`
        """
        pass
    def setMinRotateDampYRange(self, angle):
        """
        Set the minimum of the damping range in Y
        
        Parameters:
        angle : 'float'
            the damping range to set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMinRotateDampYRange`
        """
        pass
    def setMinRotateDampYStrength(self, angle):
        """
        Set the maximum of the damping strength in Y.
        
        Parameters:
        angle : 'float'
            The new damping strength value
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMinRotateDampYStrength`
        """
        pass
    def setMinRotateDampZRange(self, angle):
        """
        Set the minimum of the damping range in Z
        
        Parameters:
        angle : 'float'
            the damping range to set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMinRotateDampZRange`
        """
        pass
    def setMinRotateDampZStrength(self, angle):
        """
        Set the minimum of the damping strength in Z.
        
        Parameters:
        angle : 'float'
            The new damping strength value
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setMinRotateDampZStrength`
        """
        pass
    def setOrientation(self, quaternion):
        """
        Set the jointOrient value. This corresponds to the jointOrient attribute on the joint, which is stored internally as a quaternion. It is different from the rotation orientation defined in the transform node. Modifying the jointOrient changes the coordinate axes, which affects how scaling a joint behaves.
        
        Parameters:
        quaternion : 'Quaternion'
            the joint orientation
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setOrientation`
        """
        pass
    def setPreferedAngle(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    def setPreferredAngle(self, rotation):
        """
        Set the preferred orientation for this joint (in XYZ order)
        
        Parameters:
        rotation : ('float', 'float', 'float')
            the array into which we will store the angles
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setPreferredAngle`
        """
        pass
    def setPreferredAngles(self, val='True', **kwargs):
        """
        Meaningful only in the edit mode. It sets the preferred angles to the current joint angles.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setRadius(self, val='True', **kwargs):
        """
        Specifies the joint radius.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setScaleCompensate(self, val='True', **kwargs):
        """
        It sets the scaleCompenstate attribute of the joint to the given argument. When this is true, the scale of the parent joint will be compensated before any rotation of this joint is applied, so that the bone to the joint is scaled but not the bones to its child joints. When queried, this flag returns an boolean.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setScaleOrientation(self, quaternion):
        """
        Set the orientation of the coordinate axes for rotation. This is equivalent to calling the MFnTransform::setRotateOrientation method, and corresponds to the rotateAxis attribute on the joint node. The matrix equations used to combine the rotateAxis with the other transformation attributes of the joint are described in the description for the MFnIkJoint class.
        
        Parameters:
        quaternion : 'Quaternion'
            the rotate orientation
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setScaleOrientation`
        """
        pass
    def setSegmentScale(self, scale):
        """
        Set the local space scale values for the joint segment (bone). This is equivalent to calling Ttransform::setScale.
        
        Parameters:
        scale : ('float', 'float', 'float')
            the new scale values to set
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setSegmentScale`
        """
        pass
    def setStiffness(self, stiffness):
        """
        Set the stiffness (from 0 to 100.0) for the joint. The stiffness attribute is used by ik solvers to generate a resistance to a joint motion. The higher the stiffness the less it will rotate. Stiffness works in relative sense: it determines the willingness of this joint to rotate with respect to the other joint in the ik chain.
        
        Parameters:
        stiffness : ('float', 'float', 'float')
            the X, Y, and Z stiffness values
        
        Derived from api method `maya.OpenMayaAnim.MFnIkJoint.setStiffness`
        """
        pass
    def setStiffnessX(self, val='True', **kwargs):
        """
        Set the stiffness (from 0 to 100.0) for x-axis. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setStiffnessY(self, val='True', **kwargs):
        """
        Set the stiffness (from 0 to 100.0) for y-axis. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def setStiffnessZ(self, val='True', **kwargs):
        """
        Set the stiffness (from 0 to 100.0) for z-axis. When queried, this flag returns a float.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def symmetry(self, val='True', **kwargs):
        """
        Create a symmetric joint from the current joint.                   
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def symmetryAxis(self, val='True', **kwargs):
        """
        This flag specifies the axis used to mirror symmetric joints. Any combination of x, y, z can be used. This option is only used when the symmetry flag is set to True.                  
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    def zeroScaleOrient(self, val='True', **kwargs):
        """
        It sets the scale orientation to zero and compensate the change by modifing the translation and joint orientation for joint or rotation for general transform of all its child transformations. The flag will be ignored if the flag -so is set.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The joint command is used to create, edit, and query, joints within Maya. (The
        standard edit(-e) and query(-q) flags are used for edit and query functions). If
        the object is not specified, the currently selected object (dag object) will be
        used. Multiple objects are allowed only for the edit mode. The same edit flags
        will be applied on all the joints selected, except for -p without -r (set joint
        position in the world space). An ik handle in the object list is equivalent to
        the list of joints the ik handle commands. When -ch/children is present, all the
        child joints of the specified joints, including the joints implied by possible
        ik handles, will also be included. In the creation mode, a new joint will be
        created as a child of a selected transform or starts a hierarchy by itself if no
        transform is selected. An ik handle will be treated as a transform in the
        creation mode. The default values of the arguments are: -degreeOfFreedom xyz
        -name Joint#-position 0 0 0 -absolute -dof xyz-scale 1.0 1.0 1.0
        -scaleCompensate true -orientation 0.0 0.0 0.0 -scaleOrientation 0.0 0.0 0.0
        -limitX -360 360 -limitY -360 360 -limitZ -360 360 -angleX 0.0 -angleY 0.0
        -angleZ 0.0 -stiffnessX 0.0 -stiffnessY 0.0 -stiffnessZ 0.0 -limitSwitchX no
        -limitSwitchY no -limitSwitchZ no -rotationOrder xyz Those arguments can be
        specified in the creation mode, editied in the edit mode (-e), or queried in the
        query mode (-q).
        
        Flags:
        - absolute : a                   (bool)          [create,query,edit]
            The joint center position is in absolute world coordinates. (This is the
            default.)
        
        - angleX : ax                    (float)         [create,query,edit]
            Set the x-axis angle. When queried, this flag returns a float.
        
        - angleY : ay                    (float)         [create,query,edit]
            Set the y-axis angle. When queried, this flag returns a float.
        
        - angleZ : az                    (float)         [create,query,edit]
            Set the z-axis angle. When queried, this flag returns a float.
        
        - assumePreferredAngles : apa    (bool)          [edit]
            Meaningful only in the edit mode. It sets the joint angles to the corresponding
            preferred angles.
        
        - automaticLimits : al           (bool)          [create]
            Meaningful only in edit mode. It sets the joint to appropriate hinge joint with
            joint limits. It modifies the joint only if (a) it connects exactly to two
            joints (one parent, one child), (b) it does not lie on the line drawn between
            the two connected joints, and the plane it forms with the two connected joints
            is perpendicular to one of its rotation axes.
        
        - children : ch                  (bool)          [edit]
            It tells the command to apply all the edit options not only to the selected
            joints, but also to their descendent joints in the DAG.
        
        - component : co                 (bool)          [create,edit]
            Use with the -position switch to position the joint relative to its parent (like
            -relative) but to compute new positions for all children joints so their world
            coordinate positions do not change.
        
        - degreeOfFreedom : dof          (unicode)       [create,query,edit]
            Specifies the degrees of freedom for the IK. Valid strings consist of non-
            duplicate letters from x, y, and z. The letters in the string indicate what
            rotations are to be used by IK. The order a letter appear in the string does not
            matter. Examples are x, yz, xyz. When queried, this flag returns a string.
            Modifying dof will change the locking state of the corresponding rotation
            attributes. The rule is: if an rotation is turned into a dof, it will be
            unlocked if it is currently locked. When it is turned into a non-dof, it will be
            locked if it is not currently locked.
        
        - exists : ex                    (unicode)       [query]
            Does the named joint exist? When queried, this flag returns a boolean.
        
        - limitSwitchX : lsx             (bool)          [create,query,edit]
            Use the limit the x-axis rotation? When queried, this flag returns a boolean.
        
        - limitSwitchY : lsy             (bool)          [create,query,edit]
            Use the limit the y-axis rotation? When queried, this flag returns a boolean.
        
        - limitSwitchZ : lsz             (bool)          [create,query,edit]
            Use the Limit the z-axis rotation? When queried, this flag returns a boolean.
        
        - limitX : lx                    (float, float)  [create,query,edit]
            Set lower and upper limits on the x-axis of rotation.  Also turns on the joint
            limit. When queried, this flag returns 2 floats.
        
        - limitY : ly                    (float, float)  [create,query,edit]
            Set lower and upper limits on the y-axis of rotation.  Also turns on the joint
            limit. When queried, this flag returns 2 floats.
        
        - limitZ : lz                    (float, float)  [create,query,edit]
            Set lower and upper limits on the z-axis of rotation.  Also turns on the joint
            limit. When queried, this flag returns 2 floats.
        
        - name : n                       (unicode)       [create,query,edit]
            Specifies the name of the joint. When queried, this flag returns a string.
        
        - orientJoint : oj               (unicode)       [edit]
            The argument can be one of the following strings: xyz, yzx, zxy, zyx, yxz, xzy,
            none. It modifies the joint orientation and scale orientation so that the axis
            indicated by the first letter in the argument will be aligned with the vector
            from this joint to its first child joint. For example, if the argument is xyz,
            the x-axis will point towards the child joint. The alignment of the remaining
            two joint orient axes are dependent on whether or not the
            -sao/-secondaryAxisOrient flag is used. If the -sao flag is used, see the
            documentation for that flag for how the remaining axes are aligned. In the
            absence of a user specification for the secondary axis orientation, the rotation
            axis indicated by the last letter in the argument will be aligned with the
            vector perpendicular to first axis and the vector from this joint to its parent
            joint. The remaining axis is aligned according the right hand rule. If the
            argument is none, the joint orientation will be set to zero and its effect to
            the hierarchy below will be offset by modifying the scale orientation. The flag
            will be ignored if: A. the joint has non-zero rotations when the argument is not
            none. B. the joint does not have child joint, or the distance to the child joint
            is zero when the argument is not none. C. either flag -o or -so is set.
        
        - orientation : o                (float, float, float) [create,query,edit]
            The joint orientation. When queried, this flag returns 3 floats.
        
        - position : p                   (float, float, float) [create,query,edit]
            Specifies the position of the center of the joint. This position may be relative
            to the joint's parent or in absolute world coordinates (see -r and -a below).
            When queried, this flag returns 3 floats.
        
        - radius : rad                   (float)         [create,query,edit]
            Specifies the joint radius.
        
        - relative : r                   (bool)          [create,query,edit]
            The joint center position is relative to the joint's parent.
        
        - rotationOrder : roo            (unicode)       [create,query,edit]
            The rotation order of the joint. The argument can be one of the following
            strings: xyz, yzx, zxy, zyx, yxz, xzy.
        
        - scale : s                      (float, float, float) [create,query,edit]
            Scale of the joint. When queried, this flag returns 3 floats.
        
        - scaleCompensate : sc           (bool)          [create,query,edit]
            It sets the scaleCompenstate attribute of the joint to the given argument. When
            this is true, the scale of the parent joint will be compensated before any
            rotation of this joint is applied, so that the bone to the joint is scaled but
            not the bones to its child joints. When queried, this flag returns an boolean.
        
        - scaleOrientation : so          (float, float, float) [create,query,edit]
            Set the orientation of the coordinate axes for scaling. When queried, this flag
            returns 3 floats.
        
        - secondaryAxisOrient : sao      (unicode)       [edit]
            The argument can be one of the following strings: xup, xdown, yup, ydown, zup,
            zdown, none. This flag is used in conjunction with the -oj/orientJoint flag. It
            specifies the scene axis that the second axis should align with. For example, a
            flag combination of -oj yzx -sao yupwould result in the y-axis pointing down the
            bone, the z-axis oriented with the scene's positive y-axis, and the x-axis
            oriented according to the right hand rule.
        
        - setPreferredAngles : spa       (bool)          [edit]
            Meaningful only in the edit mode. It sets the preferred angles to the current
            joint angles.
        
        - stiffnessX : stx               (float)         [create,query,edit]
            Set the stiffness (from 0 to 100.0) for x-axis. When queried, this flag returns
            a float.
        
        - stiffnessY : sty               (float)         [create,query,edit]
            Set the stiffness (from 0 to 100.0) for y-axis. When queried, this flag returns
            a float.
        
        - stiffnessZ : stz               (float)         [create,query,edit]
            Set the stiffness (from 0 to 100.0) for z-axis. When queried, this flag returns
            a float.
        
        - symmetry : sym                 (bool)          [create,edit]
            Create a symmetric joint from the current joint.
        
        - symmetryAxis : sa              (unicode)       [create,edit]
            This flag specifies the axis used to mirror symmetric joints. Any combination of
            x, y, z can be used. This option is only used when the symmetry flag is set to
            True.
        
        - zeroScaleOrient : zso          (bool)          [edit]
            It sets the scale orientation to zero and compensate the change by modifing the
            translation and joint orientation for joint or rotation for general transform of
            all its child transformations. The flag will be ignored if the flag -so is set.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.joint`
        """
        pass
    Axis = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Constraint(Transform):
    def getRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use getRotation(quaternion=True) instead.
        """
        pass
    def getWeight(self, *targetObjects): pass
    def setRotationQuaternion(*args, **kwargs):
        """
        The function '{objName}' is deprecated and will become unavailable in future pymel versions. Use setRotation, and pass in a Quaternion object, instead.
        """
        pass
    def setWeight(self, weight, *targetObjects): pass
    __melnode__ = []
    
    
    __readonly__ = {}


class BaseLattice(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class SoftModHandle(Shape):
    __melnode__ = []
    
    
    __readonly__ = {}


class THcustomTransform(Transform):
    __melnode__ = []
    
    
    __readonly__ = {}


class RigidBody(Shape):
    def deleteCache(self, val='True', **kwargs):
        """
        Deletes the cache (if one exists) of the rigid body.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getActive(self, **kwargs):
        """
        Creates a rigid body that is active.  An active rigid body accepts and causes collisions and is effected by dynamic fields.  This is the default.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getAngularVelocity(self, **kwargs):
        """
        Current angular velocity of rigid body.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getApplyForceAt(self, **kwargs):
        """
        Determines how forces are applied to the rigid body. The choices are centerOfMass | boundingBox | verticesOrCVs. Default: boundingBox                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getBounciness(self, **kwargs):
        """
        Sets the restitution (or bounciness) of the rigid body. Range:   0.0 - 2.0 Default: 0.6                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getCache(self, **kwargs):
        """
        Turns caching on (1) or off (0) for the rigid body. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getCenterOfMass(self, **kwargs):
        """
        Sets the center of mass (x,y,z) of the rigid body. Default: actual center of mass.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getCollisions(self, **kwargs):
        """
        Truns collisions on/off for the rigid body.  If the collisions are turned of the rigid body will not collide with any other rigid body. Default: on.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getContactCount(self, **kwargs):
        """
        returns the current contact count for the rigid body.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getContactName(self, **kwargs):
        """
        returns all the rigid body names which are in contact with this shape.  One name for each contact will be returned.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getContactPosition(self, **kwargs):
        """
        returns all the contact position.  One position for each contact will be returned.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getDamping(self, **kwargs):
        """
        Sets the damping value of the rigid body. Range:   -2.0 - 2.0 Default: 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getDynamicFriction(self, **kwargs):
        """
        Sets the dynamic friction for the rigid body. Range:   0.0 - 1.0 Default: 0.2                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getForce(self, **kwargs):
        """
        Current force on the rigid body.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getIgnore(self, **kwargs):
        """
        Causes the rigid body to be ignored in the rigid solver. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getInitialAngularVelocity(self, **kwargs):
        """
        Sets the initial angular velocity of the rigid body. Default: 0.0 0.0 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getInitialVelocity(self, **kwargs):
        """
        Sets the initial velocity of the rigid body. Default: 0.0 0.0 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getLayer(self, **kwargs):
        """
        Sets the collision layer of the rigid body.  Only rigid bodies in the same collision layer can collide with each other. Range:   = 0 Default: 0.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getLockCenterOfMass(self, **kwargs):
        """
        Locks the center of mass for the rigid body. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getMass(self, **kwargs):
        """
        Sets the mass of the rigid body. Range:   0 Default: 1.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getOrientation(self, **kwargs):
        """
        Sets the initial orientation (x,y,z) of the rigid body. Default: current orientation.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getParticleCollision(self, **kwargs):
        """
        Turns the ability for a rigid body to collide with particles on and off.  The particles will exert a force on the rigid body. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getPassive(self, **kwargs):
        """
        Creates a rigid body that is passive.  A passive rigid body does not react to collisions but active rigid bodies can collide with it. Dynamic Fields will not effect a passive rigid body.  Only passive rigid bodies can be keyframed.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getPosition(self, **kwargs):
        """
        Sets the initial position (x,y,z) of the rigid body. Default: current position.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getRemoveShape(self, **kwargs):
        """
        Remove the named shape.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getSolver(self, **kwargs):
        """
        The name of the solver which this rigid node is to resided.  If the solver does not exists then the rigid body will not be created.  If the edit flag is thrown add the solver exists, the rigid body will be moved to that solver.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getStandInObject(self, **kwargs):
        """
        Causes the simulator to use a stand in object for the simulation. The choices are none | cube | sphere. The default is none. Default: none                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getStaticFriction(self, **kwargs):
        """
        Sets the static friction for the rigid body. Range:   0.0 - 1.0 Default: 0.2                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getTesselationFactor(self, **kwargs):
        """
        Sets the tesselation factor for a rigid body surface. Range:   = 10 Default: 200.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def getVelocity(self, **kwargs):
        """
        Current velocity of rigid body.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def impulse(self, val='True', **kwargs):
        """
        Applies an impulse (instantaneous) force on a rigid body. Default: 0.0 0.0 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def impulsePosition(self, val='True', **kwargs):
        """
        The position at which the impulse is applied. Default: the bodies center of mass.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setActive(self, val='True', **kwargs):
        """
        Creates a rigid body that is active.  An active rigid body accepts and causes collisions and is effected by dynamic fields.  This is the default.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setApplyForceAt(self, val='True', **kwargs):
        """
        Determines how forces are applied to the rigid body. The choices are centerOfMass | boundingBox | verticesOrCVs. Default: boundingBox                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setBounciness(self, val='True', **kwargs):
        """
        Sets the restitution (or bounciness) of the rigid body. Range:   0.0 - 2.0 Default: 0.6                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setCache(self, val='True', **kwargs):
        """
        Turns caching on (1) or off (0) for the rigid body. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setCenterOfMass(self, val='True', **kwargs):
        """
        Sets the center of mass (x,y,z) of the rigid body. Default: actual center of mass.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setCollisions(self, val='True', **kwargs):
        """
        Truns collisions on/off for the rigid body.  If the collisions are turned of the rigid body will not collide with any other rigid body. Default: on.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setDamping(self, val='True', **kwargs):
        """
        Sets the damping value of the rigid body. Range:   -2.0 - 2.0 Default: 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setDynamicFriction(self, val='True', **kwargs):
        """
        Sets the dynamic friction for the rigid body. Range:   0.0 - 1.0 Default: 0.2                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setIgnore(self, val='True', **kwargs):
        """
        Causes the rigid body to be ignored in the rigid solver. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setInitialAngularVelocity(self, val='True', **kwargs):
        """
        Sets the initial angular velocity of the rigid body. Default: 0.0 0.0 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setInitialVelocity(self, val='True', **kwargs):
        """
        Sets the initial velocity of the rigid body. Default: 0.0 0.0 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setLayer(self, val='True', **kwargs):
        """
        Sets the collision layer of the rigid body.  Only rigid bodies in the same collision layer can collide with each other. Range:   = 0 Default: 0.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setLockCenterOfMass(self, val='True', **kwargs):
        """
        Locks the center of mass for the rigid body. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setMass(self, val='True', **kwargs):
        """
        Sets the mass of the rigid body. Range:   0 Default: 1.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setOrientation(self, val='True', **kwargs):
        """
        Sets the initial orientation (x,y,z) of the rigid body. Default: current orientation.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setParticleCollision(self, val='True', **kwargs):
        """
        Turns the ability for a rigid body to collide with particles on and off.  The particles will exert a force on the rigid body. Default: off                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setPassive(self, val='True', **kwargs):
        """
        Creates a rigid body that is passive.  A passive rigid body does not react to collisions but active rigid bodies can collide with it. Dynamic Fields will not effect a passive rigid body.  Only passive rigid bodies can be keyframed.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setPosition(self, val='True', **kwargs):
        """
        Sets the initial position (x,y,z) of the rigid body. Default: current position.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setRemoveShape(self, val='True', **kwargs):
        """
        Remove the named shape.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setSolver(self, val='True', **kwargs):
        """
        The name of the solver which this rigid node is to resided.  If the solver does not exists then the rigid body will not be created.  If the edit flag is thrown add the solver exists, the rigid body will be moved to that solver.                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setStandInObject(self, val='True', **kwargs):
        """
        Causes the simulator to use a stand in object for the simulation. The choices are none | cube | sphere. The default is none. Default: none                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def setStaticFriction(self, val='True', **kwargs):
        """
        Sets the static friction for the rigid body. Range:   0.0 - 1.0 Default: 0.2                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    def spinImpulse(self, val='True', **kwargs):
        """
        Applies an spin impulse (instantaneous rotational) force on a rigid body. Default: 0.0 0.0 0.0                  
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a rigid body from a polygonal or nurbs surface.
        
        Flags:
        - active : act                   (bool)          [create,query,edit]
            Creates a rigid body that is active.  An active rigid body accepts and causes
            collisions and is effected by dynamic fields.  This is the default.
        
        - angularVelocity : av           (bool)          [query]
            Current angular velocity of rigid body.
        
        - applyForceAt : afa             (unicode)       [create,query,edit]
            Determines how forces are applied to the rigid body. The choices are
            centerOfMass | boundingBox | verticesOrCVs. Default: boundingBox
        
        - bounciness : b                 (float)         [create,query,edit]
            Sets the restitution (or bounciness) of the rigid body. Range:   0.0 - 2.0
            Default: 0.6
        
        - cache : c                      (bool)          [create,query,edit]
            Turns caching on (1) or off (0) for the rigid body. Default: off
        
        - centerOfMass : com             (float, float, float) [create,query,edit]
            Sets the center of mass (x,y,z) of the rigid body. Default: actual center of
            mass.
        
        - collisions : cl                (bool)          [create,query,edit]
            Truns collisions on/off for the rigid body.  If the collisions are turned of the
            rigid body will not collide with any other rigid body. Default: on.
        
        - contactCount : cc              (bool)          [query]
            returns the current contact count for the rigid body.
        
        - contactName : cn               (bool)          [query]
            returns all the rigid body names which are in contact with this shape.  One name
            for each contact will be returned.
        
        - contactPosition : cp           (bool)          [query]
            returns all the contact position.  One position for each contact will be
            returned.
        
        - damping : dp                   (float)         [create,query,edit]
            Sets the damping value of the rigid body. Range:   -2.0 - 2.0 Default: 0.0
        
        - deleteCache : dc               (bool)          [edit]
            Deletes the cache (if one exists) of the rigid body.
        
        - dynamicFriction : df           (float)         [create,query,edit]
            Sets the dynamic friction for the rigid body. Range:   0.0 - 1.0 Default: 0.2
        
        - force : f                      (bool)          [query]
            Current force on the rigid body.
        
        - ignore : ig                    (bool)          [create,query,edit]
            Causes the rigid body to be ignored in the rigid solver. Default: off
        
        - impulse : i                    (float, float, float) [create,edit]
            Applies an impulse (instantaneous) force on a rigid body. Default: 0.0 0.0 0.0
        
        - impulsePosition : imp          (float, float, float) [create,edit]
            The position at which the impulse is applied. Default: the bodies center of
            mass.
        
        - initialAngularVelocity : iav   (float, float, float) [create,query,edit]
            Sets the initial angular velocity of the rigid body. Default: 0.0 0.0 0.0
        
        - initialVelocity : iv           (float, float, float) [create,query,edit]
            Sets the initial velocity of the rigid body. Default: 0.0 0.0 0.0
        
        - layer : l                      (int)           [create,query,edit]
            Sets the collision layer of the rigid body.  Only rigid bodies in the same
            collision layer can collide with each other. Range:   = 0 Default: 0.
        
        - lockCenterOfMass : lcm         (bool)          [create,query,edit]
            Locks the center of mass for the rigid body. Default: off
        
        - mass : m                       (float)         [create,query,edit]
            Sets the mass of the rigid body. Range:   0 Default: 1.0
        
        - name : n                       (unicode)       [create,query,edit]
            Assigns the rigid body the given name.
        
        - orientation : o                (float, float, float) [create,query,edit]
            Sets the initial orientation (x,y,z) of the rigid body. Default: current
            orientation.
        
        - particleCollision : pc         (bool)          [create,query,edit]
            Turns the ability for a rigid body to collide with particles on and off.  The
            particles will exert a force on the rigid body. Default: off
        
        - passive : pas                  (bool)          [create,query,edit]
            Creates a rigid body that is passive.  A passive rigid body does not react to
            collisions but active rigid bodies can collide with it. Dynamic Fields will not
            effect a passive rigid body.  Only passive rigid bodies can be keyframed.
        
        - position : p                   (float, float, float) [create,query,edit]
            Sets the initial position (x,y,z) of the rigid body. Default: current position.
        
        - removeShape : rs               (unicode)       [create,query,edit]
            Remove the named shape.
        
        - solver : slv                   (unicode)       [create,query,edit]
            The name of the solver which this rigid node is to resided.  If the solver does
            not exists then the rigid body will not be created.  If the edit flag is thrown
            add the solver exists, the rigid body will be moved to that solver.
        
        - spinImpulse : si               (float, float, float) [create,edit]
            Applies an spin impulse (instantaneous rotational) force on a rigid body.
            Default: 0.0 0.0 0.0
        
        - standInObject : sio            (unicode)       [create,query,edit]
            Causes the simulator to use a stand in object for the simulation. The choices
            are none | cube | sphere. The default is none. Default: none
        
        - staticFriction : sf            (float)         [create,query,edit]
            Sets the static friction for the rigid body. Range:   0.0 - 1.0 Default: 0.2
        
        - tesselationFactor : tf         (int)           [create,query]
            Sets the tesselation factor for a rigid body surface. Range:   = 10 Default:
            200.
        
        - velocity : vel                 (bool)          [query]
            Current velocity of rigid body.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.rigidBody`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ImagePlane(Shape):
    def detach(self, val='True', **kwargs):
        """
        This flag can only be used in the edit mode, when this flag is used in edit, it will detach current image plane from any camera it attaches to and make it a free image plane.                             
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def fileName(self, val='True', **kwargs):
        """
        Set the image name for image plane to read.                                
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getCamera(self, **kwargs):
        """
        When creating, it will try to attach the created image plane to the specified camera. If the given camera is invalid, creating will fail. When querying, it will query which camera current image plane is attaching to. If it has no camera attached to (free image plane), it will return an empty string. When edit, it will make the image plane attach to the new specified camera. If the camera given is invalid, it will do nothing. When the image plane is attached to a camera, the image plane's transform node will be set identity. The detach command will not restore the original position of the image plane. but the undo command will restore the original position of the image plane.                                
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getDropFrame(self, **kwargs):
        """
        Query the 'drop frame' flag of the movie's timecode format.                                
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getFrameDuration(self, **kwargs):
        """
        Query the frame duration of the movie's timecode format.                                   
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the image plane. When creating, if this flag is not specified, it will use 10.0 as default height.                               
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getImageSize(self, **kwargs):
        """
        Get size of the loaded image.                              
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getLookThrough(self, **kwargs):
        """
        The camera currently used for image plane to look through.                                 
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getMaintainRatio(self, **kwargs):
        """
        Let the image plane respect the picture aspect ratio. When creating, if this flag is not specified, it will use true as default value.                             
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getNegTimesOK(self, **kwargs):
        """
        Query the 'neg times OK' flag of the movie's timecode format.                              
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getNumFrames(self, **kwargs):
        """
        Query the whole number of frames per second of the movie's timecode format.                                
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getQuickTime(self, **kwargs):
        """
        Query whether the image plane is using a QuickTime movie.                                  
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getShowInAllViews(self, **kwargs):
        """
        The flag is used to show the current image plane in all views or not.                              
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getTimeCode(self, **kwargs):
        """
        Query the whole number of frames per second of the movie's timecode format.                                
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getTimeCodeTrack(self, **kwargs):
        """
        Query whether the movie on the image plane has a timecode track.                                   
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getTimeScale(self, **kwargs):
        """
        Query the timescale of the movie's timecode format.                                
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getTwentyFourHourMax(self, **kwargs):
        """
        Query the '24 hour max' flag of the movie's timecode format.                               
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def getWidth(self, **kwargs):
        """
        Width of the image plane. When creating, if this flag is not specified, it will use 10.0 as default width.                                 Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def setCamera(self, val='True', **kwargs):
        """
        When creating, it will try to attach the created image plane to the specified camera. If the given camera is invalid, creating will fail. When querying, it will query which camera current image plane is attaching to. If it has no camera attached to (free image plane), it will return an empty string. When edit, it will make the image plane attach to the new specified camera. If the camera given is invalid, it will do nothing. When the image plane is attached to a camera, the image plane's transform node will be set identity. The detach command will not restore the original position of the image plane. but the undo command will restore the original position of the image plane.                                
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the image plane. When creating, if this flag is not specified, it will use 10.0 as default height.                               
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def setLookThrough(self, val='True', **kwargs):
        """
        The camera currently used for image plane to look through.                                 
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def setMaintainRatio(self, val='True', **kwargs):
        """
        Let the image plane respect the picture aspect ratio. When creating, if this flag is not specified, it will use true as default value.                             
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def setShowInAllViews(self, val='True', **kwargs):
        """
        The flag is used to show the current image plane in all views or not.                              
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        Width of the image plane. When creating, if this flag is not specified, it will use 10.0 as default width.                                 Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The imagePlane command allows querying of various properties of         an image
        plane and any movie in use by the image plane. It also supports         creating
        and edit.         The object passed to the command may either be an imagePlane
        node,         or a camera, in which case the command uses the image plane
        attached         to the camera (if any). If no object is passed in, the current
        selection is used.         Currently, most movie related queries work only on 64
        bit Windows systems.
        
        Flags:
        - camera : c                     (unicode)       [create,query,edit]
            When creating, it will try to attach the created image plane to the specified
            camera. If the given camera is invalid, creating will fail. When querying, it
            will query which camera current image plane is attaching to. If it has no camera
            attached to (free image plane), it will return an empty string. When edit, it
            will make the image plane attach to the new specified camera. If the camera
            given is invalid, it will do nothing. When the image plane is attached to a
            camera, the image plane's transform node will be set identity. The detach
            command will not restore the original position of the image plane. but the undo
            command will restore the original position of the image plane.
        
        - counter : cn                   (bool)          []
            Query the 'counter' flag of the movie's timecode format. If this is true, the
            timecode returned by the -timeCode flag will be a simple counter. If false, the
            returned timecode will be an array of integers (hours, minutes, seconds,
            frames).
        
        - detach : d                     (bool)          [edit]
            This flag can only be used in the edit mode, when this flag is used in edit, it
            will detach current image plane from any camera it attaches to and make it a
            free image plane.
        
        - dropFrame : df                 (bool)          [query]
            Query the 'drop frame' flag of the movie's timecode format.
        
        - fileName : fn                  (unicode)       [create,edit]
            Set the image name for image plane to read.
        
        - frameDuration : fd             (int)           [query]
            Query the frame duration of the movie's timecode format.
        
        - height : h                     (float)         [create,query,edit]
            Height of the image plane. When creating, if this flag is not specified, it will
            use 10.0 as default height.
        
        - imageSize : iz                 (int, int)      [query]
            Get size of the loaded image.
        
        - lookThrough : lt               (unicode)       [create,query,edit]
            The camera currently used for image plane to look through.
        
        - maintainRatio : mr             (bool)          [create,query,edit]
            Let the image plane respect the picture aspect ratio. When creating, if this
            flag is not specified, it will use true as default value.
        
        - name : n                       (unicode)       [create,query]
            Set the image plane node name when creating or return the image plane name when
            querying.
        
        - negTimesOK : nt                (bool)          [query]
            Query the 'neg times OK' flag of the movie's timecode format.
        
        - numFrames : nf                 (int)           [query]
            Query the whole number of frames per second of the movie's timecode format.
        
        - quickTime : qt                 (bool)          [query]
            Query whether the image plane is using a QuickTime movie.
        
        - showInAllViews : sia           (bool)          [create,query,edit]
            The flag is used to show the current image plane in all views or not.
        
        - timeCode : tc                  (int)           [query]
            Query the whole number of frames per second of the movie's timecode format.
        
        - timeCodeTrack : tt             (bool)          [query]
            Query whether the movie on the image plane has a timecode track.
        
        - timeScale : ts                 (int)           [query]
            Query the timescale of the movie's timecode format.
        
        - twentyFourHourMax : tf         (bool)          [query]
            Query the '24 hour max' flag of the movie's timecode format.
        
        - width : w                      (float)         [create,query,edit]
            Width of the image plane. When creating, if this flag is not specified, it will
            use 10.0 as default width.                                 Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.imagePlane`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PfxHair(PfxGeometry):
    __melnode__ = []
    
    
    __readonly__ = {}


class SurfaceVarGroup(BaseGeometryVarGroup):
    __melnode__ = []
    
    
    __readonly__ = {}


class DistanceDimShape(DimensionShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class PointOnPolyConstraint(Constraint):
    def getOffset(self, **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    def skip(self, val='True', **kwargs):
        """
        Specify the axis to be skipped. Valid values are x, y, zand none. During creation, noneis the default. This flag is multi-use.                  
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's position to the position of the target object or to the
        average position of a number of targets. A pointOnPolyConstraint takes as input
        one or more targetDAG transform nodes at which to position the single constraint
        objectDAG transform node.  The pointOnPolyConstraint positions the constrained
        object at the weighted average of the world space position target objects.
        
        Flags:
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - maintainOffset : mo            (bool)          [create]
            The offset necessary to preserve the constrained object's initial position will
            be calculated and used as the offset.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - offset : o                     (float, float, float) [create,query,edit]
            Sets or queries the value of the offset. Default is 0,0,0.
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - skip : sk                      (unicode)       [create,edit]
            Specify the axis to be skipped. Valid values are x, y, zand none. During
            creation, noneis the default. This flag is multi-use.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.pointOnPolyConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderLight(Light):
    __melnode__ = []
    
    
    __readonly__ = {}


class OrientConstraint(Constraint):
    def createCache(self, val='True', **kwargs):
        """
        This flag is used to generate an animation curve that serves as a cache for the constraint. The two arguments define the start and end frames.  The cache is useful if the constraint has multiple targets and the constraint's interpolation type is set to no flip. The no flipmode prevents flipping during playback, but the result is dependent on the previous frame.  Therefore in order to consistently get the same result on a specific frame, a cache must be generated. This flag creates the cache and sets the constraint's interpolation type to cache. If a cache exists already, it will be deleted and replaced with a new cache.                   
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def deleteCache(self, val='True', **kwargs):
        """
        Delete an existing interpolation cache.                  
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def getOffset(self, **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    def skip(self, val='True', **kwargs):
        """
        Specify the axis to be skipped. Valid values are x, y, zand none. The default value in create mode is none. This flag is multi-use.                  
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's orientation to match the orientation of the target or the
        average of a number of targets. An orientConstraint takes as input one or more
        targetDAG transform nodes to control the orientation of the single constraint
        objectDAG transform  The orientConstraint orients the constrained object to
        match the weighted average of the target world space orientations.
        
        Flags:
        - createCache : cc               (float, float)  [edit]
            This flag is used to generate an animation curve that serves as a cache for the
            constraint. The two arguments define the start and end frames.  The cache is
            useful if the constraint has multiple targets and the constraint's interpolation
            type is set to no flip. The no flipmode prevents flipping during playback, but
            the result is dependent on the previous frame.  Therefore in order to
            consistently get the same result on a specific frame, a cache must be generated.
            This flag creates the cache and sets the constraint's interpolation type to
            cache. If a cache exists already, it will be deleted and replaced with a new
            cache.
        
        - deleteCache : dc               (bool)          [edit]
            Delete an existing interpolation cache.
        
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - maintainOffset : mo            (bool)          [create]
            The offset necessary to preserve the constrained object's initial orientation
            will be calculated and used as the offset.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - offset : o                     (float, float, float) [create,query,edit]
            Sets or queries the value of the offset. Default is 0,0,0.
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - skip : sk                      (unicode)       [create,edit]
            Specify the axis to be skipped. Valid values are x, y, zand none. The default
            value in create mode is none. This flag is multi-use.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.orientConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DirectedDisc(GeometryShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class Assembly(DagContainer):
    def activate(self, representation):
        """
        Activate a representation. The representation to activate is specified as a string name. Passing in an empty string argument means inactivate the previously-active representation (if any), and activate no representation.
        
        Parameters:
        representation : 'unicode'
            Representation to activate.
        
        Derived from api method `maya.OpenMaya.MFnAssembly.activate`
        """
        pass
    def activateNonRecursive(self, representation):
        """
        Activate a representation, but prevent any nested assemblies created and initialized during this activation from activating any of their representations.
        
        Parameters:
        representation : 'unicode'
            Representation to activate.
        
        Derived from api method `maya.OpenMaya.MFnAssembly.activateNonRecursive`
        """
        pass
    def canActivate(self):
        """
        Determines whether this assembly can activate a representation, for the node attached to this function set.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.canActivate`
        """
        pass
    def canRepApplyEdits(self, representation):
        """
        Determines whether the given representation can apply edits to its data, for the node attached to this function set.
        
        Parameters:
        representation : 'unicode'
            Representation to query.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.canRepApplyEdits`
        """
        pass
    def createRepresentation(self, val='True', **kwargs):
        """
        Create and add a specific type of representation for an assembly. If the representation type needs additional parameters, they must be specified using the inputflag. For example, the Maya scene assembly reference implementation Cache and Scene representations need an input file.                                    
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def deleteAllRepresentations(self):
        """
        Delete all representations managed by the node attached to this function set.
        Derived from api method `maya.OpenMaya.MFnAssembly.deleteAllRepresentations`
        """
        pass
    def deleteRepresentation(self, representation):
        """
        Delete a representation managed by the node attached to this function set.
        
        Parameters:
        representation : 'unicode'
            Representation to delete.
        
        Derived from api method `maya.OpenMaya.MFnAssembly.deleteRepresentation`
        """
        pass
    def deregister(self, val='True', **kwargs):
        """
        Deregister a registered assembly type. If the deregistered type is the default type, the default type will be set to the empty string.                             
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getAbsoluteRepNamespace(self):
        """
        Get the fully-qualified (absolute) namespace for representations of this assembly node. This is the namespace where nodes created by the activation of a representation will be added. This namespace is shared by all representations.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getAbsoluteRepNamespace`
        """
        pass
    def getActive(self):
        """
        Get the active representation in the list of representations. If the list of representations is empty, the status code will be kSuccess, and the return string will be empty.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getActive`
        """
        pass
    def getActiveLabel(self, **kwargs):
        """
        Set the active representation by label, or query the label of the active representation. Edit mode can be applied to more than one assembly. Query mode will return a single string when only a single assembly is specified, and will return an array of strings when multiple assemblies are specified.                                  
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getCanCreate(self, **kwargs):
        """
        Query the representation types the specific assembly can create.                                   
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getCreateOptionBoxProc(self, **kwargs):
        """
        Set or query the option box menu procedure for a specific assembly type. The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type.                                   
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getDefaultType(self, **kwargs):
        """
        Set or query the default type of assembly.  When the assembly command is used to perform an operation on an assembly type rather than on an assembly object, it will be performed on the default type, unless the -type flag is used to specify an explicit assembly type.                                 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getInitialRep(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    def getIsAType(self, **kwargs):
        """
        Query whether the given object is of an assembly type.                             
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getIsTrackingMemberEdits(self, **kwargs):
        """
        Query whether the given object is tracking member edits.                                   
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Set or query the label for an assembly type. Assembly type is specified with flag type. If no type specified, the default type is used.                                    
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getListRepTypes(self, **kwargs):
        """
        Query the supported representation types for a given assembly type.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type.                               
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getListRepTypesProc(self, **kwargs):
        """
        Set or query the procedure that provides the representation type list which an assembly type supports.  This procedure takes no argument, and returns a string array of representation types that represents the full set of representation types this assembly type can create.  The assembly type for which this procedure applies will be the default type, unless the type flag is used to specify an explicit assembly type.                                  
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getListRepresentations(self, **kwargs):
        """
        Query the created representations list for a specific assembly.  The -repType flag can be used to filter the list and return representations for a single representation type.  If the -repType flag is not used, all created representations will be returned.                                    
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getListTypes(self, **kwargs):
        """
        Query the supported assembly types.                                
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getParentAssembly(self):
        """
        Return the immediate parent assembly of this assembly if there is one, otherwise return a null object. An assembly with no parent is a top level assembly.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getParentAssembly`
        """
        pass
    def getPostCreateUIProc(self, **kwargs):
        """
        Set or query the UI post-creation procedure for a given assembly type. This procedure will be invoked by Maya immediately after an assembly of the specified type is created from the UI, but not through scripting.  It can be used to invoke a dialog, to obtain and set initial parameters on a newly-created assembly.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type.                                
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getRepLabel(self, representation):
        """
        Get the label of the specified representation. The label of a representation is a string that is meant to be shown in the UI and identify the representation meaningfully to a user. The representation label should support localization requirements. If the specified representation is not found in this assembly, an empty string is returned.
        
        Parameters:
        representation : 'unicode'
            Representation whose label must be returned.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getRepLabel`
        """
        pass
    def getRepNamespace(self):
        """
        Get the representations namespace of this assembly node. This is the namespace where nodes created by the activation of a representation will be added. This namespace is shared by all representations. The name can be updated by Maya if a name clash occurs when the namespace is added to its parent namespace (see MPxAssembly::updateRepNamespace() for details).
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getRepNamespace`
        """
        pass
    def getRepPostCreateUIProc(self, **kwargs):
        """
        Set or query the UI post-creation procedure for a specific representation type, and for a specific assembly type.  This procedure takes two arguments, the first the DAG path to the assembly, and the second the name of the representation.  It returns no value.  It will be invoked by Maya immediately after a representation of the specified type is created from the UI, but not through scripting.  It can be used to invoke a dialog, to obtain and set initial parameters on a newly-created representation.  The representation type is the argument of this flag. The -proc flag must be used to specify the procedure name.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type. 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getRepPreCreateUIProc(self, **kwargs):
        """
        Set or query the UI pre-creation procedure for a specific representation type, and for a specific assembly type.  This procedure takes no argument, and returns a string that is passed as an argument to the -input flag when Maya invokes the assembly command with the -createRepresentation flag. The representation pre-creation procedure is invoked by Maya immediately before creating a representation of the specified type from the UI, but not through scripting.  It can be used to invoke a dialog, to obtain the creation argument for a new representation.  The representation type is the argument of this flag.  The -proc flag must be used to specify the procedure name.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type. 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getRepType(self, representation):
        """
        Get the type of the specified representation. The type string does not have to be user-readable, and does not have to be localized; the type label should be used for UI purposes. If the specified representation is not found in this assembly, an empty string is returned.
        
        Parameters:
        representation : 'unicode'
            Representation whose type must be returned.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getRepType`
        """
        pass
    def getRepTypeLabel(self, **kwargs):
        """
        Query the label of the specific representation type. 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getRepTypeLabelProc(self, **kwargs):
        """
        Set or query the procedure that provides the representation type label, for a given assembly type.  The procedure takes the representation type as its sole argument, and returns a localized representation type label. The assembly type for which this procedure applies will be the default type, unless the -type flag is used to specify an explicit assembly type.                                  
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def getRepresentations(self):
        """
        Returns an array of the representations managed by the node attached to this function set.
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getRepresentations`
        """
        pass
    def getSubAssemblies(self):
        """
        Returns a list containing direct children of this assembly that are themselves assemblies, for the currently active representation. The returned list will be empty if there are no assembly children of the currently active representation.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getSubAssemblies`
        """
        pass
    def getType(self, **kwargs):
        """
        Set or query properties for the specified registered assembly type. Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def handlesAddEdits(self):
        """
        Determines whether the assembly supplies edits to its data, for the node attached to this function set.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.handlesAddEdits`
        """
        pass
    def importFile(self, fileName, type='None', preserveReferences='False', nameSpace='None', ignoreVersion='False'):
        """
        Import the scene elements from the given file into this assembly. See MFileIO::importFile() for more information. All elements imported from the file become members of the assembly. DAG nodes in the imported file that are parented to world are parented to the assembly. DAG nodes in the imported file whose parent is not world keep their existing parenting relationship.
        
        Parameters:
        fileName : 'unicode'
            name of the file from which to import objects
        type : 'unicode'
            if NULL, Maya will try to deduce the type of the file. If not NULL, it must contain a file type to use when importing the file.
        preserveReferences : 'bool'
            Boolean to indicate whether the references need to be preserved.
        nameSpace : 'unicode'
            optional name of the namespace to use when importing objects. Use NULL for default of no namespace.
        ignoreVersion : 'bool'
            Boolean to control whether to ignore version when importing a file.
        
        Derived from api method `maya.OpenMaya.MFnAssembly.importFile`
        """
        pass
    def input(self, val='True', **kwargs):
        """
        Specify the additional parameters of representation creation procedure when creating a representation. This flag must be used with createRepresentation flag.                              
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def isActive(self, representation):
        """
        Determines whether the given representation is the active representation for the node attached to this function set.
        
        Parameters:
        representation : 'unicode'
            Representation to query.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.isActive`
        """
        pass
    def isTopLevel(self):
        """
        Returns whether this assembly node is a top-level assembly. An assembly node is a top-level assembly if no container in its (possibly empty) chain of nesting parent containers is an assembly. Of course, this includes the trivial case of its immediate parent container being null.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.isTopLevel`
        """
        pass
    def newRepLabel(self, val='True', **kwargs):
        """
        Specify the representation label to set on representation label edit.                              
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def postLoad(self):
        """
        Method to initialize assemblies after their creation.
        Derived from api method `maya.OpenMaya.MFnAssembly.postLoad`
        """
        pass
    def proc(self, val='True', **kwargs):
        """
        Specify the procedure when setting the representation UI post- or pre-creation procedure, for a given assembly type.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type.                              
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def renameRepresentation(self, val='True', **kwargs):
        """
        Renames the representation that is the argument to this flag.  The repName flag must be used to provide the new name.                              
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def repName(self, val='True', **kwargs):
        """
        Specify the representation name to set on representation creation or rename. This flag is optional with the createRepresentation flag: if omitted, the assembly will name the representation.  It is mandatory with the renameRepresentation flag.                                 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def repTypes(self):
        """
        Return the list of representation types that can be created for this assembly node.
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnAssembly.repTypes`
        """
        pass
    def setActive(self, val='True', **kwargs):
        """
        Set the active representation by name, or query the name of the active representation. Edit mode can be applied to more than one assembly. Query mode will return a single string when only a single assembly is specified, and will return an array of strings when multiple assemblies are specified. Using an empty string as name means to inactivate the currently active representation.                             
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setActiveLabel(self, val='True', **kwargs):
        """
        Set the active representation by label, or query the label of the active representation. Edit mode can be applied to more than one assembly. Query mode will return a single string when only a single assembly is specified, and will return an array of strings when multiple assemblies are specified.                                  
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setCreateOptionBoxProc(self, val='True', **kwargs):
        """
        Set or query the option box menu procedure for a specific assembly type. The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type.                                   
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setDefaultType(self, val='True', **kwargs):
        """
        Set or query the default type of assembly.  When the assembly command is used to perform an operation on an assembly type rather than on an assembly object, it will be performed on the default type, unless the -type flag is used to specify an explicit assembly type.                                 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Set or query the label for an assembly type. Assembly type is specified with flag type. If no type specified, the default type is used.                                    
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setListRepTypesProc(self, val='True', **kwargs):
        """
        Set or query the procedure that provides the representation type list which an assembly type supports.  This procedure takes no argument, and returns a string array of representation types that represents the full set of representation types this assembly type can create.  The assembly type for which this procedure applies will be the default type, unless the type flag is used to specify an explicit assembly type.                                  
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setPostCreateUIProc(self, val='True', **kwargs):
        """
        Set or query the UI post-creation procedure for a given assembly type. This procedure will be invoked by Maya immediately after an assembly of the specified type is created from the UI, but not through scripting.  It can be used to invoke a dialog, to obtain and set initial parameters on a newly-created assembly.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type.                                
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setRepLabel(self, representation, label):
        """
        Change the representation label.
        
        Parameters:
        representation : 'unicode'
            Representation name.
        label : 'unicode'
            New representation label.
        
        Derived from api method `maya.OpenMaya.MFnAssembly.setRepLabel`
        """
        pass
    def setRepName(self, representation, newName):
        """
        Rename a representation.
        
        Parameters:
        representation : 'unicode'
            Current representation name.
        newName : 'unicode'
            New representation name starting point.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.setRepName`
        """
        pass
    def setRepPostCreateUIProc(self, val='True', **kwargs):
        """
        Set or query the UI post-creation procedure for a specific representation type, and for a specific assembly type.  This procedure takes two arguments, the first the DAG path to the assembly, and the second the name of the representation.  It returns no value.  It will be invoked by Maya immediately after a representation of the specified type is created from the UI, but not through scripting.  It can be used to invoke a dialog, to obtain and set initial parameters on a newly-created representation.  The representation type is the argument of this flag. The -proc flag must be used to specify the procedure name.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type. 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setRepPreCreateUIProc(self, val='True', **kwargs):
        """
        Set or query the UI pre-creation procedure for a specific representation type, and for a specific assembly type.  This procedure takes no argument, and returns a string that is passed as an argument to the -input flag when Maya invokes the assembly command with the -createRepresentation flag. The representation pre-creation procedure is invoked by Maya immediately before creating a representation of the specified type from the UI, but not through scripting.  It can be used to invoke a dialog, to obtain the creation argument for a new representation.  The representation type is the argument of this flag.  The -proc flag must be used to specify the procedure name.  The assembly type will be the default type, unless the -type flag is used to specify an explicit assembly type. 
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setRepTypeLabelProc(self, val='True', **kwargs):
        """
        Set or query the procedure that provides the representation type label, for a given assembly type.  The procedure takes the representation type as its sole argument, and returns a localized representation type label. The assembly type for which this procedure applies will be the default type, unless the -type flag is used to specify an explicit assembly type.                                  
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def setType(self, val='True', **kwargs):
        """
        Set or query properties for the specified registered assembly type. Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    def supportsEdits(self):
        """
        Does this assembly support edit tracking?
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.supportsEdits`
        """
        pass
    def supportsMemberChanges(self):
        """
        Can members of the assembly be changed?
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAssembly.supportsMemberChanges`
        """
        pass
    @classmethod
    def getTopLevelAssemblies(self):
        """
        Returns a list containing top-level assemblies. These are assemblies that are not nested inside another assembly.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnAssembly.getTopLevelAssemblies`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command to register assemblies for the scene assembly framework, to create them,
        and to edit and query them. Assembly nodes are DAG nodes, and are therefore
        shown in the various DAG editors (Outliner, Hypergraph, Node Editor). At
        assembly creation time, the node name defaults to the node type name. The
        assembly command can create any node that is derived from the assembly node base
        class.  It also acts as a registry of these types, so that various scripting
        callbacks can be defined and registered with the assembly command.  These
        callbacks are invoked by Maya during operations on assembly nodes, and can be
        used to customize behavior. In query mode, return type is based on queried flag.
        
        Flags:
        - active : a                     (unicode)       [query,edit]
            Set the active representation by name, or query the name of the active
            representation. Edit mode can be applied to more than one assembly. Query mode
            will return a single string when only a single assembly is specified, and will
            return an array of strings when multiple assemblies are specified. Using an
            empty string as name means to inactivate the currently active representation.
        
        - activeLabel : al               (unicode)       [query,edit]
            Set the active representation by label, or query the label of the active
            representation. Edit mode can be applied to more than one assembly. Query mode
            will return a single string when only a single assembly is specified, and will
            return an array of strings when multiple assemblies are specified.
        
        - canCreate : cc                 (unicode)       [query]
            Query the representation types the specific assembly can create.
        
        - createOptionBoxProc : cob      (script)        [query,edit]
            Set or query the option box menu procedure for a specific assembly type. The
            assembly type will be the default type, unless the -type flag is used to specify
            an explicit assembly type.
        
        - createRepresentation : cr      (unicode)       [edit]
            Create and add a specific type of representation for an assembly. If the
            representation type needs additional parameters, they must be specified using
            the inputflag. For example, the Maya scene assembly reference implementation
            Cache and Scene representations need an input file.
        
        - defaultType : dt               (unicode)       [query,edit]
            Set or query the default type of assembly.  When the assembly command is used to
            perform an operation on an assembly type rather than on an assembly object, it
            will be performed on the default type, unless the -type flag is used to specify
            an explicit assembly type.
        
        - deleteRepresentation : dr      (unicode)       [edit]
            Delete a specific representation from an assembly.
        
        - deregister : d                 (unicode)       [edit]
            Deregister a registered assembly type. If the deregistered type is the default
            type, the default type will be set to the empty string.
        
        - input : input                  (unicode)       [edit]
            Specify the additional parameters of representation creation procedure when
            creating a representation. This flag must be used with createRepresentation
            flag.
        
        - isAType : isa                  (unicode)       [query]
            Query whether the given object is of an assembly type.
        
        - isTrackingMemberEdits : ite    (unicode)       [query]
            Query whether the given object is tracking member edits.
        
        - label : lbl                    (unicode)       [query,edit]
            Set or query the label for an assembly type. Assembly type is specified with
            flag type. If no type specified, the default type is used.
        
        - listRepTypes : lrt             (bool)          [query]
            Query the supported representation types for a given assembly type.  The
            assembly type will be the default type, unless the -type flag is used to specify
            an explicit assembly type.
        
        - listRepTypesProc : lrp         (script)        [query,edit]
            Set or query the procedure that provides the representation type list which an
            assembly type supports.  This procedure takes no argument, and returns a string
            array of representation types that represents the full set of representation
            types this assembly type can create.  The assembly type for which this procedure
            applies will be the default type, unless the type flag is used to specify an
            explicit assembly type.
        
        - listRepresentations : lr       (bool)          [query]
            Query the created representations list for a specific assembly.  The -repType
            flag can be used to filter the list and return representations for a single
            representation type.  If the -repType flag is not used, all created
            representations will be returned.
        
        - listTypes : lt                 (bool)          [query]
            Query the supported assembly types.
        
        - name : n                       (unicode)       [create]
            Specify the name of the assembly when creating it.
        
        - newRepLabel : nrl              (unicode)       [edit]
            Specify the representation label to set on representation label edit.
        
        - postCreateUIProc : aoc         (script)        [query,edit]
            Set or query the UI post-creation procedure for a given assembly type. This
            procedure will be invoked by Maya immediately after an assembly of the specified
            type is created from the UI, but not through scripting.  It can be used to
            invoke a dialog, to obtain and set initial parameters on a newly-created
            assembly.  The assembly type will be the default type, unless the -type flag is
            used to specify an explicit assembly type.
        
        - proc : prc                     (script)        [edit]
            Specify the procedure when setting the representation UI post- or pre-creation
            procedure, for a given assembly type.  The assembly type will be the default
            type, unless the -type flag is used to specify an explicit assembly type.
        
        - renameRepresentation : rnr     (unicode)       [edit]
            Renames the representation that is the argument to this flag.  The repName flag
            must be used to provide the new name.
        
        - repLabel : rl                  (unicode)       [query,edit]
            Query or edit the label of the representation that is the argument to this flag,
            for a given assembly.  In both query and edit modes, the -repLabel flag
            specifies the name of the representation.  In edit mode, the -newRepLabel flag
            must be used to specify the new representation label.
        
        - repName : rnm                  (unicode)       [edit]
            Specify the representation name to set on representation creation or rename.
            This flag is optional with the createRepresentation flag: if omitted, the
            assembly will name the representation.  It is mandatory with the
            renameRepresentation flag.
        
        - repNamespace : rns             (unicode)       [query]
            Query the representation namespace of this assembly node. The value returned is
            used by Maya for creating the namespace where nodes created by the activation of
            a representation will be added. If a name clash occurs when the namespace is
            added to its parent namespace, Maya will update repNamespace with the new name.
            Two namespaces are involved when dealing with an assembly node: the namespace of
            the assembly node itself (which this flag does not affect or query), and the
            namespace of its representations. The representation namespace is a child of its
            assembly node's namespace. The assembly node's namespace is set by its
            containing assembly, if it is nested, or by the top-level file. Either the
            assembly node's namespace, or the representation namespace, or both, can be the
            empty string. It should be noted that if the assembly node is nested, the
            assembly node's namespace will be (by virtue of its nesting) the representation
            namespace of its containing assembly.
        
        - repPostCreateUIProc : poc      (unicode)       [query,edit]
            Set or query the UI post-creation procedure for a specific representation type,
            and for a specific assembly type.  This procedure takes two arguments, the first
            the DAG path to the assembly, and the second the name of the representation.  It
            returns no value.  It will be invoked by Maya immediately after a representation
            of the specified type is created from the UI, but not through scripting.  It can
            be used to invoke a dialog, to obtain and set initial parameters on a newly-
            created representation.  The representation type is the argument of this flag.
            The -proc flag must be used to specify the procedure name.  The assembly type
            will be the default type, unless the -type flag is used to specify an explicit
            assembly type.
        
        - repPreCreateUIProc : pec       (unicode)       [query,edit]
            Set or query the UI pre-creation procedure for a specific representation type,
            and for a specific assembly type.  This procedure takes no argument, and returns
            a string that is passed as an argument to the -input flag when Maya invokes the
            assembly command with the -createRepresentation flag. The representation pre-
            creation procedure is invoked by Maya immediately before creating a
            representation of the specified type from the UI, but not through scripting.  It
            can be used to invoke a dialog, to obtain the creation argument for a new
            representation.  The representation type is the argument of this flag.  The
            -proc flag must be used to specify the procedure name.  The assembly type will
            be the default type, unless the -type flag is used to specify an explicit
            assembly type.
        
        - repType : rt                   (unicode)       [query]
            Specify a representation type to use as a filter for the -listRepresentations
            query.  The representation type is the argument to this flag.
        
        - repTypeLabel : rtl             (unicode)       [query]
            Query the label of the specific representation type.
        
        - repTypeLabelProc : rtp         (script)        [query,edit]
            Set or query the procedure that provides the representation type label, for a
            given assembly type.  The procedure takes the representation type as its sole
            argument, and returns a localized representation type label. The assembly type
            for which this procedure applies will be the default type, unless the -type flag
            is used to specify an explicit assembly type.
        
        - type : typ                     (unicode)       [create,query,edit]
            Set or query properties for the specified registered assembly type. Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.assembly`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OldNormalConstraint(Constraint):
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformTwist(DeformFunc):
    __melnode__ = []
    
    
    __readonly__ = {}


class ImplicitCone(GeometryShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class SymmetryConstraint(Constraint):
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmPalette(THcustomTransform):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ParentConstraint(Constraint):
    def createCache(self, val='True', **kwargs):
        """
        This flag is used to generate an animation curve that serves as a cache for the constraint. The two arguments define the start and end frames.  The cache is useful if the constraint has multiple targets and the constraint's interpolation type is set to no flip. The no flipmode prevents flipping during playback, but the result is dependent on the previous frame. Therefore in order to consistently get the same result on a specific frame, a cache must be generated. This flag creates the cache and sets the constraint's interpolation type to cache. If a cache exists already, it will be deleted and replaced with a new cache.                  
        
        
        Derived from mel command `maya.cmds.parentConstraint`
        """
        pass
    def deleteCache(self, val='True', **kwargs):
        """
        Delete an existing interpolation cache.                  
        
        
        Derived from mel command `maya.cmds.parentConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.parentConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.parentConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.parentConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.parentConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's position and rotation so that it behaves as if it were a
        child of the target object(s). In the case of multiple targets, the overall
        position and rotation of the constrained object is the weighted average of each
        target's contribution to the position and rotation of the object. A
        parentConstraint takes as input one or more targetDAG transform nodes at which
        to position and rotate the single constraint objectDAG transform node.  The
        parentConstraint positions and rotates the constrained object at the weighted
        average of the world space position, rotation and scale target objects.
        
        Flags:
        - createCache : cc               (float, float)  [edit]
            This flag is used to generate an animation curve that serves as a cache for the
            constraint. The two arguments define the start and end frames.  The cache is
            useful if the constraint has multiple targets and the constraint's interpolation
            type is set to no flip. The no flipmode prevents flipping during playback, but
            the result is dependent on the previous frame. Therefore in order to
            consistently get the same result on a specific frame, a cache must be generated.
            This flag creates the cache and sets the constraint's interpolation type to
            cache. If a cache exists already, it will be deleted and replaced with a new
            cache.
        
        - decompRotationToChild : dr     (bool)          [create]
            During constraint creation, if the rotation offset between the constrained
            object and the target object is maintained, this flag indicates close to which
            object the offset rotation is decomposed. Setting this flag will make the
            rotation decomposition close to the constrained object instead of the target
            object, which is the default setting.
        
        - deleteCache : dc               (bool)          [edit]
            Delete an existing interpolation cache.
        
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - maintainOffset : mo            (bool)          [create]
            If this flag is specified the position and rotation of the constrained object
            will be maintained.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - skipRotate : sr                (unicode)       [create]
            Causes the axis specified not to be considered when constraining rotation.
            Valid arguments are x, y, zand none.
        
        - skipTranslate : st             (unicode)       [create]
            Causes the axis specified not to be considered when constraining translation.
            Valid arguments are x, y, zand none.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.parentConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SubdivSurfaceVarGroup(BaseGeometryVarGroup):
    __melnode__ = []
    
    
    __readonly__ = {}


class NormalConstraint(Constraint):
    def getAimVector(self, **kwargs):
        """
        Set the aim vector.  This is the vector in local coordinates that points at the target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def getUpVector(self, **kwargs):
        """
        Set local up vector.  This is the vector in local coordinates that aligns with the world up vector.  If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def getWorldUpObject(self, **kwargs):
        """
        Set the DAG object use for worldUpType objectand objectrotation. See worldUpType for greater detail. The default value is no up object, which is interpreted as world space.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def getWorldUpType(self, **kwargs):
        """
        Set the type of the world up vector computation. The worldUpType can have one of 5 values: scene, object, objectrotation, vector, or none. If the value is scene, the upVector is aligned with the up axis of the scene and worldUpVector and worldUpObject are ignored. If the value is object, the upVector is aimed as closely as possible to the origin of the space of the worldUpObject and the worldUpVector is ignored. If the value is objectrotationthen the worldUpVector is interpreted as being in the coordinate space of the worldUpObject, transformed into world space and the upVector is aligned as closely as possible to the result. If the value is vector, the upVector is aligned with worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if the value is noneno twist calculation is performed by the constraint, with the resulting upVectororientation based previous orientation of the constrained object, and the great circlerotation needed to align the aim vector with its constraint. The default worldUpType is vector.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def getWorldUpVector(self, **kwargs):
        """
        Set world up vector.  This is the vector in world coordinates that up vector should align with. See -wut/worldUpType (below)for greater detail. If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def setAimVector(self, val='True', **kwargs):
        """
        Set the aim vector.  This is the vector in local coordinates that points at the target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def setUpVector(self, val='True', **kwargs):
        """
        Set local up vector.  This is the vector in local coordinates that aligns with the world up vector.  If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def setWorldUpObject(self, val='True', **kwargs):
        """
        Set the DAG object use for worldUpType objectand objectrotation. See worldUpType for greater detail. The default value is no up object, which is interpreted as world space.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def setWorldUpType(self, val='True', **kwargs):
        """
        Set the type of the world up vector computation. The worldUpType can have one of 5 values: scene, object, objectrotation, vector, or none. If the value is scene, the upVector is aligned with the up axis of the scene and worldUpVector and worldUpObject are ignored. If the value is object, the upVector is aimed as closely as possible to the origin of the space of the worldUpObject and the worldUpVector is ignored. If the value is objectrotationthen the worldUpVector is interpreted as being in the coordinate space of the worldUpObject, transformed into world space and the upVector is aligned as closely as possible to the result. If the value is vector, the upVector is aligned with worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if the value is noneno twist calculation is performed by the constraint, with the resulting upVectororientation based previous orientation of the constrained object, and the great circlerotation needed to align the aim vector with its constraint. The default worldUpType is vector.                  
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    def setWorldUpVector(self, val='True', **kwargs):
        """
        Set world up vector.  This is the vector in world coordinates that up vector should align with. See -wut/worldUpType (below)for greater detail. If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's orientation based on the normal of the target surface(s)
        at the closest point(s) to the object. A normalConstraint takes as input one or
        more surface shapes (the targets) and a DAG transform node (the object).  The
        normalConstraint orients the constrained object such that the aimVector (in the
        object's local coordinate system) aligns in world space to combined normal
        vector.  The upVector (again the the object's local coordinate system) is
        aligned in world space with the worldUpVector.  The combined normal vector is a
        weighted average of the normal vector for each target surface at the point
        closest to the constrained object.
        
        Flags:
        - aimVector : aim                (float, float, float) [create,query,edit]
            Set the aim vector.  This is the vector in local coordinates that points at the
            target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is
            used.
        
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - upVector : u                   (float, float, float) [create,query,edit]
            Set local up vector.  This is the vector in local coordinates that aligns with
            the world up vector.  If not given at creation time, the default value of (0.0,
            1.0, 0.0) is used.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag
        
        - worldUpObject : wuo            (PyNode)        [create,query,edit]
            Set the DAG object use for worldUpType objectand objectrotation. See worldUpType
            for greater detail. The default value is no up object, which is interpreted as
            world space.
        
        - worldUpType : wut              (unicode)       [create,query,edit]
            Set the type of the world up vector computation. The worldUpType can have one of
            5 values: scene, object, objectrotation, vector, or none. If the value is scene,
            the upVector is aligned with the up axis of the scene and worldUpVector and
            worldUpObject are ignored. If the value is object, the upVector is aimed as
            closely as possible to the origin of the space of the worldUpObject and the
            worldUpVector is ignored. If the value is objectrotationthen the worldUpVector
            is interpreted as being in the coordinate space of the worldUpObject,
            transformed into world space and the upVector is aligned as closely as possible
            to the result. If the value is vector, the upVector is aligned with
            worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if
            the value is noneno twist calculation is performed by the constraint, with the
            resulting upVectororientation based previous orientation of the constrained
            object, and the great circlerotation needed to align the aim vector with its
            constraint. The default worldUpType is vector.
        
        - worldUpVector : wu             (float, float, float) [create,query,edit]
            Set world up vector.  This is the vector in world coordinates that up vector
            should align with. See -wut/worldUpType (below)for greater detail. If not given
            at creation time, the default value of (0.0, 1.0, 0.0) is used.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.normalConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class LightEditor(LightGroup):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformableShape(GeometryShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class GreasePlane(ImagePlane):
    __melnode__ = []
    
    
    __readonly__ = {}


class ImplicitSphere(GeometryShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class CollisionModel(DynBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class THconstraint(Constraint):
    __melnode__ = []
    
    
    __readonly__ = {}


class Field(DynBase):
    def falloffCurve(self, param):
        """
        Returns falloff given the param in [0,1]. This is enabled if the use the maximum distance is enabled.
        
        Parameters:
        param : 'float'
            Parameter
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnField.falloffCurve`
        """
        pass
    def getAttenuation(self):
        """
        Returns the rate of change where the strength of the field changes as the distance between the field and the affected object increases.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnField.attenuation`
        """
        pass
    def getForceAtPoint(self, point, velocity, mass, deltaTime='0.041666666666666664'):
        """
        Compute the force of a field on an array of points, given their position, velocity, and mass. Note that only the Air and Vortex fields require a time increment to compute forces, all other fields will ignore this argument.
        
        Parameters:
        point : List['Point']
            array of positions for each point.
        velocity : List['Vector']
            array of velocities for each point. If the length of the velocity array is 0, a velocity of 0.0 is assumed for all the points. Note the velocity array is a requirement for the Air and Drag fields to compute forces.
        mass : List['float']
            array of mass values for each point. If the length of the mass array is 0, a mass of 1.0 is assumed for all the points.
        deltaTime : 'float'
            time increment in seconds for usage with the Air and Vortex fields. Default is (1.0 / 24.0 fps).
        
        
        Returns:
        List['Vector']
        
        Derived from api method `maya.OpenMayaFX.MFnField.getForceAtPoint`
        """
        pass
    def getMagnitude(self):
        """
        Returns the strength of the field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnField.magnitude`
        """
        pass
    def getMaxDistance(self):
        """
        Returns the maximum distance from the field at which the force of the field is exerted. The Use Max Distance setting must be turned on for maximum distance to take effect. The maximum distance is scaled by the falloff curve's non-zero range.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnField.maxDistance`
        """
        pass
    def getPerVertex(self):
        """
        Returns true if the field exerts its force on each individual point (cv, particle, vertex) equally. Returns false if the force is exerted only from the geometric center of the object or set of points.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnField.perVertex`
        """
        pass
    def getUseMaxDistance(self):
        """
        Returns true if the field will use the maximum distance setting to determine the area of influence.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnField.useMaxDistance`
        """
        pass
    def isFalloffCurveConstantOne(self):
        """
        Returns true if falloffCurve is a constant one (default) or false if not.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnField.isFalloffCurveConstantOne`
        """
        pass
    def setAttenuation(self, atten):
        """
        Sets the rate of change where the strength of the field changes as the distance between the field and the affected object increases.
        
        Parameters:
        atten : 'float'
            A positive value representing the exponent for rate of change. A value of 0 and the force remains constant over distance.
        
        Derived from api method `maya.OpenMayaFX.MFnField.setAttenuation`
        """
        pass
    def setMagnitude(self, mag):
        """
        Sets the strength of the field.
        
        Parameters:
        mag : 'float'
            A value representing the strength of the field.
        
        Derived from api method `maya.OpenMayaFX.MFnField.setMagnitude`
        """
        pass
    def setMaxDistance(self, dist):
        """
        Sets the maximum distance from the field at which the force of the field is exerted. The Use Max Distance setting must be turned on for maximum distance to take effect.
        
        Parameters:
        dist : 'float'
            A value representing distance in internal linear units.
        
        Derived from api method `maya.OpenMayaFX.MFnField.setMaxDistance`
        """
        pass
    def setPerVertex(self, enable):
        """
        Enables the field to exert its force on each individual point (cv, particle, vertex) equally. Otherwise, the force is exerted only from the geometric center of the object or set of points.
        
        Parameters:
        enable : 'bool'
            Flag to enable or disable individual point forces.
        
        Derived from api method `maya.OpenMayaFX.MFnField.setPerVertex`
        """
        pass
    def setUseMaxDistance(self, enable):
        """
        Enables the field to use the maximum distance setting to determine the area of influence.
        
        Parameters:
        enable : 'bool'
            Flag to enable or disable maximum distance.
        
        Derived from api method `maya.OpenMayaFX.MFnField.setUseMaxDistance`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Locator(GeometryShape):
    def absolute(self, val='True', **kwargs):
        """
        If set, the locator's position is in world space.                  
        
        
        Derived from mel command `maya.cmds.spaceLocator`
        """
        pass
    def getPosition(self, **kwargs):
        """
        Location in  3-dimensional space where locator is to be created.                  
        
        
        Derived from mel command `maya.cmds.spaceLocator`
        """
        pass
    def relative(self, val='True', **kwargs):
        """
        If set, the locator's position is relative to its local space. The locator is created in relative mode by default.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.spaceLocator`
        """
        pass
    def setPosition(self, val='True', **kwargs):
        """
        Location in  3-dimensional space where locator is to be created.                  
        
        
        Derived from mel command `maya.cmds.spaceLocator`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The command creates a locator at the specified position in space. By default it
        is created at (0,0,0).
        
        Flags:
        - absolute : a                   (bool)          [create,edit]
            If set, the locator's position is in world space.
        
        - name : n                       (unicode)       [create,edit]
            Name for the locator.
        
        - position : p                   (float, float, float) [create,query,edit]
            Location in  3-dimensional space where locator is to be created.
        
        - relative : r                   (bool)          [create,edit]
            If set, the locator's position is relative to its local space. The locator is
            created in relative mode by default.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.spaceLocator`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'spaceLocator'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ScaleConstraint(Constraint):
    def getOffset(self, **kwargs):
        """
        Sets or queries the value of the offset. Default is 1,1,1.                  
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    def scaleCompensate(self, val='True', **kwargs):
        """
        Used only when constraining a joint. It specify if a scaleCompensate will be applied on constrained joint. If true it will connect Tjoint.aCompensateForParentScale to scaleContraint.aConstraintScaleCompensate.                  
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        Sets or queries the value of the offset. Default is 1,1,1.                  
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    def skip(self, val='True', **kwargs):
        """
        Specify the axis to be skipped. Valid values are x, y, zand none. During creation, noneis the default. This flag is multi-use.                  
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's scale to the scale of the target object or to the average
        scale of a number of targets. A scaleConstraint takes as input one or more
        targetDAG transform nodes to which to scale the single constraint objectDAG
        transform node.  The scaleConstraint scales the constrained object at the
        weighted geometric mean of the world space target scale factors.
        
        Flags:
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - maintainOffset : mo            (bool)          [create]
            The offset necessary to preserve the constrained object's initial scale will be
            calculated and used as the offset.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - offset : o                     (float, float, float) [create,query,edit]
            Sets or queries the value of the offset. Default is 1,1,1.
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - scaleCompensate : sc           (bool)          [create,edit]
            Used only when constraining a joint. It specify if a scaleCompensate will be
            applied on constrained joint. If true it will connect
            Tjoint.aCompensateForParentScale to scaleContraint.aConstraintScaleCompensate.
        
        - skip : sk                      (unicode)       [create,edit]
            Specify the axis to be skipped. Valid values are x, y, zand none. During
            creation, noneis the default. This flag is multi-use.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.scaleConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ImplicitBox(GeometryShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyExtrudeEdge(PolyMoveEdge):
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getDivisions(self, **kwargs):
        """
        How many internal edges are creating when pulling. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getGain(self, **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getKeepFacesTogether(self, **kwargs):
        """
        How to extrude edges. If on, extruded faces produced from the edges being extruded will be kept together. Otherwise they are pulled independently. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalCenter(self, **kwargs):
        """
        Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalDirection(self, **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalDirectionX(self, **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalDirectionY(self, **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalDirectionZ(self, **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalRotate(self, **kwargs):
        """
        The local rotations. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalRotateX(self, **kwargs):
        """
        Local rotate X coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalRotateY(self, **kwargs):
        """
        Local rotate Y coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalRotateZ(self, **kwargs):
        """
        Local rotate Z coord : Rotation along the normal. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalScale(self, **kwargs):
        """
        Local Scale. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalScaleX(self, **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalScaleY(self, **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalScaleZ(self, **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalTranslate(self, **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalTranslateX(self, **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalTranslateY(self, **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getLocalTranslateZ(self, **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getOffset(self, **kwargs):
        """
        Edges are moved this distance in the opposite direction of the edge. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getPivotX(self, **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getPivotY(self, **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getPivotZ(self, **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getRandom(self, **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getRotate(self, **kwargs):
        """
        Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getRotateX(self, **kwargs):
        """
        Rotation angle around X.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getRotateY(self, **kwargs):
        """
        Rotation angle around Y.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getRotateZ(self, **kwargs):
        """
        Rotation angle around Z.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getScale(self, **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getScaleX(self, **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getScaleY(self, **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getScaleZ(self, **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getSmoothingAngle(self, **kwargs):
        """
        Angle below which new edges will be smoothed Default:kPi/6.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTaper(self, **kwargs):
        """
        Taper or Scale along the extrusion path Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTaperCurve_FloatValue(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTaperCurve_Interp(self, **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTaperCurve_Position(self, **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getThickness(self, **kwargs):
        """
        Edges are moved this distance in the direction of the connected face normals. Default:0.0f                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTranslate(self, **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTranslateX(self, **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTranslateY(self, **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTranslateZ(self, **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getTwist(self, **kwargs):
        """
        Twist or Rotation along the extrusion path Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setDivisions(self, val='True', **kwargs):
        """
        How many internal edges are creating when pulling. Default:1                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setGain(self, val='True', **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setKeepFacesTogether(self, val='True', **kwargs):
        """
        How to extrude edges. If on, extruded faces produced from the edges being extruded will be kept together. Otherwise they are pulled independently. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalCenter(self, val='True', **kwargs):
        """
        Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalDirection(self, val='True', **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalDirectionX(self, val='True', **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalDirectionY(self, val='True', **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalDirectionZ(self, val='True', **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalRotate(self, val='True', **kwargs):
        """
        The local rotations. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalRotateX(self, val='True', **kwargs):
        """
        Local rotate X coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalRotateY(self, val='True', **kwargs):
        """
        Local rotate Y coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalRotateZ(self, val='True', **kwargs):
        """
        Local rotate Z coord : Rotation along the normal. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalScale(self, val='True', **kwargs):
        """
        Local Scale. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalScaleX(self, val='True', **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalScaleY(self, val='True', **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalScaleZ(self, val='True', **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalTranslate(self, val='True', **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalTranslateX(self, val='True', **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalTranslateY(self, val='True', **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setLocalTranslateZ(self, val='True', **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        Edges are moved this distance in the opposite direction of the edge. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setPivotX(self, val='True', **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setPivotY(self, val='True', **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setPivotZ(self, val='True', **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setRandom(self, val='True', **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setRotate(self, val='True', **kwargs):
        """
        Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setRotateX(self, val='True', **kwargs):
        """
        Rotation angle around X.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setRotateY(self, val='True', **kwargs):
        """
        Rotation angle around Y.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setRotateZ(self, val='True', **kwargs):
        """
        Rotation angle around Z.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setScaleX(self, val='True', **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setScaleY(self, val='True', **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setScaleZ(self, val='True', **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setSmoothingAngle(self, val='True', **kwargs):
        """
        Angle below which new edges will be smoothed Default:kPi/6.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTaper(self, val='True', **kwargs):
        """
        Taper or Scale along the extrusion path Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTaperCurve_FloatValue(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTaperCurve_Interp(self, val='True', **kwargs):
        """
        ????? Default:0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTaperCurve_Position(self, val='True', **kwargs):
        """
        ?????                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setThickness(self, val='True', **kwargs):
        """
        Edges are moved this distance in the direction of the connected face normals. Default:0.0f                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTranslate(self, val='True', **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTranslateX(self, val='True', **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTranslateY(self, val='True', **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTranslateZ(self, val='True', **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setTwist(self, val='True', **kwargs):
        """
        Twist or Rotation along the extrusion path Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Extrude edges separately or together.
        
        Flags:
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - createCurve : cc               (bool)          [create]
            If true then the operation can create a curve.
        
        - divisions : d                  (int)           [create,query,edit]
            How many internal edges are creating when pulling. Default:1
        
        - frozen : fzn                   (bool)          []
        
        - gain : ga                      (float)         [create,query,edit]
            Gain factor per component. Can be painted using Artisan. Default:1.0
        
        - inputCurve : inc               (PyNode)        [create]
            This flag specifies the name of the curve to be used as input for the operation.
        
        - keepFacesTogether : kft        (bool)          [create,query,edit]
            How to extrude edges. If on, extruded faces produced from the edges being
            extruded will be kept together. Otherwise they are pulled independently.
            Default:true
        
        - localCenter : lc               (int)           [create,query,edit]
            Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0
        
        - localDirection : ld            (float, float, float) [create,query,edit]
            Direction to determine X axis for local space. Default:1.0, 0.0, 0.0
        
        - localDirectionX : ldx          (float)         [create,query,edit]
            X coord of the X axis.
        
        - localDirectionY : ldy          (float)         [create,query,edit]
            Y coord of the X axis.
        
        - localDirectionZ : ldz          (float)         [create,query,edit]
            Z coord of the X axis.
        
        - localRotate : lr               (float, float, float) [create,query,edit]
            The local rotations. Default:0.0, 0.0, 0.0
        
        - localRotateX : lrx             (float)         [create,query,edit]
            Local rotate X coord. The range is [0, 360].
        
        - localRotateY : lry             (float)         [create,query,edit]
            Local rotate Y coord. The range is [0, 360].
        
        - localRotateZ : lrz             (float)         [create,query,edit]
            Local rotate Z coord : Rotation along the normal. The range is [0, 360].
        
        - localScale : ls                (float, float, float) [create,query,edit]
            Local Scale. Default:1.0, 1.0, 1.0
        
        - localScaleX : lsx              (float)         [create,query,edit]
            Scale X coord.
        
        - localScaleY : lsy              (float)         [create,query,edit]
            Scale Y coord.
        
        - localScaleZ : lsz              (float)         [create,query,edit]
            Scale Z coord.
        
        - localTranslate : lt            (float, float, float) [create,query,edit]
            Local translate. Default:0.0, 0.0, 0.0
        
        - localTranslateX : ltx          (float)         [create,query,edit]
            Local translation X coord.
        
        - localTranslateY : lty          (float)         [create,query,edit]
            Local translation Y coord.
        
        - localTranslateZ : ltz          (float)         [create,query,edit]
            Local translation Z coord : Move along the normal.
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - offset : off                   (float)         [create,query,edit]
            Edges are moved this distance in the opposite direction of the edge. Default:0.0
        
        - pivot : pvt                    (float, float, float) [create,query,edit]
            The pivot for scaling and rotation. Default:0.0, 0.0, 0.0
        
        - pivotX : pvx                   (float)         [create,query,edit]
            Pivot X coord.
        
        - pivotY : pvy                   (float)         [create,query,edit]
            Pivot Y coord.
        
        - pivotZ : pvz                   (float)         [create,query,edit]
            Pivot Z coord.
        
        - random : ran                   (float)         [create,query,edit]
            Random value for all parameters. Default:0.0
        
        - rotate : ro                    (float, float, float) [create,query,edit]
            Rotation angles around X, Y, Z. Default:0.0, 0.0, 0.0
        
        - rotateX : rx                   (float)         [create,query,edit]
            Rotation angle around X.
        
        - rotateY : ry                   (float)         [create,query,edit]
            Rotation angle around Y.
        
        - rotateZ : rz                   (float)         [create,query,edit]
            Rotation angle around Z.
        
        - scale : s                      (float, float, float) [create,query,edit]
            Scaling vector. Default:1.0, 1.0, 1.0
        
        - scaleX : sx                    (float)         [create,query,edit]
            Scale X coord.
        
        - scaleY : sy                    (float)         [create,query,edit]
            Scale Y coord.
        
        - scaleZ : sz                    (float)         [create,query,edit]
            Scale Z coord.
        
        - smoothingAngle : sma           (float)         [create,query,edit]
            Angle below which new edges will be smoothed Default:kPi/6.0
        
        - taper : tp                     (float)         [create,query,edit]
            Taper or Scale along the extrusion path Default:1.0
        
        - taperCurve_FloatValue : cfv    (float)         [create,query,edit]
            ?????
        
        - taperCurve_Interp : ci         (int)           [create,query,edit]
            ????? Default:0
        
        - taperCurve_Position : cp       (float)         [create,query,edit]
            ?????
        
        - thickness : tk                 (float)         [create,query,edit]
            Edges are moved this distance in the direction of the connected face normals.
            Default:0.0f
        
        - translate : t                  (float, float, float) [create,query,edit]
            Translation vector. Default:0.0, 0.0, 0.0
        
        - translateX : tx                (float)         [create,query,edit]
            Translation X coord.
        
        - translateY : ty                (float)         [create,query,edit]
            Translation Y coord.
        
        - translateZ : tz                (float)         [create,query,edit]
            Translation Z coord.
        
        - twist : twt                    (float)         [create,query,edit]
            Twist or Rotation along the extrusion path Default:0.0
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyExtrudeEdge`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TangentConstraint(Constraint):
    def getAimVector(self, **kwargs):
        """
        Set the aim vector.  This is the vector in local coordinates that points at the target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def getUpVector(self, **kwargs):
        """
        Set local up vector.  This is the vector in local coordinates that aligns with the world up vector.  If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def getWorldUpObject(self, **kwargs):
        """
        Set the DAG object use for worldUpType objectand objectrotation. See worldUpType for greater detail. The default value is no up object, which is interpreted as world space.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def getWorldUpType(self, **kwargs):
        """
        Set the type of the world up vector computation. The worldUpType can have one of 5 values: scene, object, objectrotation, vector, or none. If the value is scene, the upVector is aligned with the up axis of the scene and worldUpVector and worldUpObject are ignored. If the value is object, the upVector is aimed as closely as possible to the origin of the space of the worldUpObject and the worldUpVector is ignored. If the value is objectrotationthen the worldUpVector is interpreted as being in the coordinate space of the worldUpObject, transformed into world space and the upVector is aligned as closely as possible to the result. If the value is vector, the upVector is aligned with worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if the value is noneno twist calculation is performed by the constraint, with the resulting upVectororientation based previous orientation of the constrained object, and the great circlerotation needed to align the aim vector with its constraint. The default worldUpType is vector.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def getWorldUpVector(self, **kwargs):
        """
        Set world up vector.  This is the vector in world coordinates that up vector should align with. See -wut/worldUpType (below)for greater detail. If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def setAimVector(self, val='True', **kwargs):
        """
        Set the aim vector.  This is the vector in local coordinates that points at the target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def setUpVector(self, val='True', **kwargs):
        """
        Set local up vector.  This is the vector in local coordinates that aligns with the world up vector.  If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def setWorldUpObject(self, val='True', **kwargs):
        """
        Set the DAG object use for worldUpType objectand objectrotation. See worldUpType for greater detail. The default value is no up object, which is interpreted as world space.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def setWorldUpType(self, val='True', **kwargs):
        """
        Set the type of the world up vector computation. The worldUpType can have one of 5 values: scene, object, objectrotation, vector, or none. If the value is scene, the upVector is aligned with the up axis of the scene and worldUpVector and worldUpObject are ignored. If the value is object, the upVector is aimed as closely as possible to the origin of the space of the worldUpObject and the worldUpVector is ignored. If the value is objectrotationthen the worldUpVector is interpreted as being in the coordinate space of the worldUpObject, transformed into world space and the upVector is aligned as closely as possible to the result. If the value is vector, the upVector is aligned with worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if the value is noneno twist calculation is performed by the constraint, with the resulting upVectororientation based previous orientation of the constrained object, and the great circlerotation needed to align the aim vector with its constraint. The default worldUpType is vector.                  
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    def setWorldUpVector(self, val='True', **kwargs):
        """
        Set world up vector.  This is the vector in world coordinates that up vector should align with. See -wut/worldUpType (below)for greater detail. If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's orientation based on the tangent of the target curve[s] at
        the closest point[s] to the object. A tangentConstraint takes as input one or
        more NURBS curves (the targets) and a DAG transform node (the object).  The
        tangentConstraint orients the constrained object such that the aimVector (in the
        object's local coordinate system) aligns in world space to combined tangent
        vector.  The upVector (again the the object's local coordinate system) is
        aligned in world space with the worldUpVector.  The combined tangent vector is a
        weighted average of the tangent vector for each target curve at the point
        closest to the constrained object.
        
        Flags:
        - aimVector : aim                (float, float, float) [create,query,edit]
            Set the aim vector.  This is the vector in local coordinates that points at the
            target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is
            used.
        
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - upVector : u                   (float, float, float) [create,query,edit]
            Set local up vector.  This is the vector in local coordinates that aligns with
            the world up vector.  If not given at creation time, the default value of (0.0,
            1.0, 0.0) is used.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag
        
        - worldUpObject : wuo            (PyNode)        [create,query,edit]
            Set the DAG object use for worldUpType objectand objectrotation. See worldUpType
            for greater detail. The default value is no up object, which is interpreted as
            world space.
        
        - worldUpType : wut              (unicode)       [create,query,edit]
            Set the type of the world up vector computation. The worldUpType can have one of
            5 values: scene, object, objectrotation, vector, or none. If the value is scene,
            the upVector is aligned with the up axis of the scene and worldUpVector and
            worldUpObject are ignored. If the value is object, the upVector is aimed as
            closely as possible to the origin of the space of the worldUpObject and the
            worldUpVector is ignored. If the value is objectrotationthen the worldUpVector
            is interpreted as being in the coordinate space of the worldUpObject,
            transformed into world space and the upVector is aligned as closely as possible
            to the result. If the value is vector, the upVector is aligned with
            worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if
            the value is noneno twist calculation is performed by the constraint, with the
            resulting upVectororientation based previous orientation of the constrained
            object, and the great circlerotation needed to align the aim vector with its
            constraint. The default worldUpType is vector.
        
        - worldUpVector : wu             (float, float, float) [create,query,edit]
            Set world up vector.  This is the vector in world coordinates that up vector
            should align with. See -wut/worldUpType (below)for greater detail. If not given
            at creation time, the default value of (0.0, 1.0, 0.0) is used.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.tangentConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OldTangentConstraint(Constraint):
    __melnode__ = []
    
    
    __readonly__ = {}


class ClusterFlexorShape(FlexorShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class Plane(GeometryShape):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The command creates a sketch plane (also known as a construction plane) in
        space.  To create an object (such as a NURBS curve, joint chain or polygon) on a
        construction plane, you need to first make the plane live. See also the makeLive
        command.
        
        Flags:
        - length : l                     (float)         [create]
            The length of plane. linearmeans that this flag can handle values with units.
        
        - name : n                       (unicode)       [create]
            Name the resulting object.
        
        - position : p                   (float, float, float) [create]
            3D position where the centre of the plane is positioned. linearmeans that this
            flag can handle values with units.
        
        - rotation : r                   (float, float, float) [create]
            The rotation of plane. anglemeans that this flag can handle values with units.
        
        - size : s                       (float)         [create]
            The combined size (size x size) of plane. linearmeans that this flag can handle
            values with units.
        
        - width : w                      (float)         [create]
            The width of plane. linearmeans that this flag can handle values with units.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.plane`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HikFKJoint(Joint):
    __melnode__ = []
    
    
    __readonly__ = {}


class Stroke(PfxGeometry):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The stroke command creates a new Paint Effects stroke node.
        
        Flags:
        - name : n                       (unicode)       [create]
            Sets the name of the stroke to the input string
        
        - pressure : pr                  (bool)          [create]
            On creation, allows the copying of the pressure mapping settings from the Paint
            Effects Tool. Default is false.
        
        - seed : s                       (int)           [create]
            Sets the random seed for this stroke.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.stroke`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MeshVarGroup(BaseGeometryVarGroup):
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyMoveFace(PolyMoveEdge):
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformSquash(DeformFunc):
    __melnode__ = []
    
    
    __readonly__ = {}


class PointConstraint(Constraint):
    def getOffset(self, **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    def skip(self, val='True', **kwargs):
        """
        Specify the axis to be skipped. Valid values are x, y, zand none. During creation, noneis the default. This flag is multi-use.                  
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's position to the position of the target object or to the
        average position of a number of targets. A pointConstraint takes as input one or
        more targetDAG transform nodes at which to position the single constraint
        objectDAG transform node.  The pointConstraint positions the constrained object
        at the weighted average of the world space position target objects.
        
        Flags:
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - maintainOffset : mo            (bool)          [create]
            The offset necessary to preserve the constrained object's initial position will
            be calculated and used as the offset.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - offset : o                     (float, float, float) [create,query,edit]
            Sets or queries the value of the offset. Default is 0,0,0.
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - skip : sk                      (unicode)       [create,edit]
            Specify the axis to be skipped. Valid values are x, y, zand none. During
            creation, noneis the default. This flag is multi-use.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.pointConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AimConstraint(Constraint):
    def getAimVector(self, **kwargs):
        """
        Set the aim vector.  This is the vector in local coordinates that points at the target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def getOffset(self, **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def getUpVector(self, **kwargs):
        """
        Set local up vector.  This is the vector in local coordinates that aligns with the world up vector.  If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def getWorldUpObject(self, **kwargs):
        """
        Set the DAG object use for worldUpType objectand objectrotation. See worldUpType for greater detail. The default value is no up object, which is interpreted as world space.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def getWorldUpType(self, **kwargs):
        """
        Set the type of the world up vector computation. The worldUpType can have one of 5 values: scene, object, objectrotation, vector, or none. If the value is scene, the upVector is aligned with the up axis of the scene and worldUpVector and worldUpObject are ignored. If the value is object, the upVector is aimed as closely as possible to the origin of the space of the worldUpObject and the worldUpVector is ignored. If the value is objectrotationthen the worldUpVector is interpreted as being in the coordinate space of the worldUpObject, transformed into world space and the upVector is aligned as closely as possible to the result. If the value is vector, the upVector is aligned with worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if the value is noneno twist calculation is performed by the constraint, with the resulting upVectororientation based previous orientation of the constrained object, and the great circlerotation needed to align the aim vector with its constraint. The default worldUpType is vector.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def getWorldUpVector(self, **kwargs):
        """
        Set world up vector.  This is the vector in world coordinates that up vector should align with. See -wut/worldUpType (below)for greater detail. If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def setAimVector(self, val='True', **kwargs):
        """
        Set the aim vector.  This is the vector in local coordinates that points at the target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        Sets or queries the value of the offset. Default is 0,0,0.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def setUpVector(self, val='True', **kwargs):
        """
        Set local up vector.  This is the vector in local coordinates that aligns with the world up vector.  If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def setWorldUpObject(self, val='True', **kwargs):
        """
        Set the DAG object use for worldUpType objectand objectrotation. See worldUpType for greater detail. The default value is no up object, which is interpreted as world space.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def setWorldUpType(self, val='True', **kwargs):
        """
        Set the type of the world up vector computation. The worldUpType can have one of 5 values: scene, object, objectrotation, vector, or none. If the value is scene, the upVector is aligned with the up axis of the scene and worldUpVector and worldUpObject are ignored. If the value is object, the upVector is aimed as closely as possible to the origin of the space of the worldUpObject and the worldUpVector is ignored. If the value is objectrotationthen the worldUpVector is interpreted as being in the coordinate space of the worldUpObject, transformed into world space and the upVector is aligned as closely as possible to the result. If the value is vector, the upVector is aligned with worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if the value is noneno twist calculation is performed by the constraint, with the resulting upVectororientation based previous orientation of the constrained object, and the great circlerotation needed to align the aim vector with its constraint. The default worldUpType is vector.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def setWorldUpVector(self, val='True', **kwargs):
        """
        Set world up vector.  This is the vector in world coordinates that up vector should align with. See -wut/worldUpType (below)for greater detail. If not given at creation time, the default value of (0.0, 1.0, 0.0) is used.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    def skip(self, val='True', **kwargs):
        """
        Specify the axis to be skipped. Valid values are x, y, zand none. During creation, noneis the default.                  
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's orientation to point at a target object or at the average
        position of a number of targets. An aimConstraint takes as input one or more
        targetDAG transform nodes at which to aim the single constraint objectDAG
        transform node.  The aimConstraint orients the constrained object such that the
        aimVector (in the object's local coordinate system) points to the in weighted
        average of the world space position target objects.  The upVector (again the the
        object's local coordinate system) is aligned in world space with the
        worldUpVector.
        
        Flags:
        - aimVector : aim                (float, float, float) [create,query,edit]
            Set the aim vector.  This is the vector in local coordinates that points at the
            target.  If not given at creation time, the default value of (1.0, 0.0, 0.0) is
            used.
        
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - maintainOffset : mo            (bool)          [create]
            The offset necessary to preserve the constrained object's initial rotation will
            be calculated and used as the offset.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - offset : o                     (float, float, float) [create,query,edit]
            Sets or queries the value of the offset. Default is 0,0,0.
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - skip : sk                      (unicode)       [create,edit]
            Specify the axis to be skipped. Valid values are x, y, zand none. During
            creation, noneis the default.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - upVector : u                   (float, float, float) [create,query,edit]
            Set local up vector.  This is the vector in local coordinates that aligns with
            the world up vector.  If not given at creation time, the default value of (0.0,
            1.0, 0.0) is used.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag
        
        - worldUpObject : wuo            (PyNode)        [create,query,edit]
            Set the DAG object use for worldUpType objectand objectrotation. See worldUpType
            for greater detail. The default value is no up object, which is interpreted as
            world space.
        
        - worldUpType : wut              (unicode)       [create,query,edit]
            Set the type of the world up vector computation. The worldUpType can have one of
            5 values: scene, object, objectrotation, vector, or none. If the value is scene,
            the upVector is aligned with the up axis of the scene and worldUpVector and
            worldUpObject are ignored. If the value is object, the upVector is aimed as
            closely as possible to the origin of the space of the worldUpObject and the
            worldUpVector is ignored. If the value is objectrotationthen the worldUpVector
            is interpreted as being in the coordinate space of the worldUpObject,
            transformed into world space and the upVector is aligned as closely as possible
            to the result. If the value is vector, the upVector is aligned with
            worldUpVector as closely as possible and worldUpMatrix is ignored. Finally, if
            the value is noneno twist calculation is performed by the constraint, with the
            resulting upVectororientation based previous orientation of the constrained
            object, and the great circlerotation needed to align the aim vector with its
            constraint. The default worldUpType is vector.
        
        - worldUpVector : wu             (float, float, float) [create,query,edit]
            Set world up vector.  This is the vector in world coordinates that up vector
            should align with. See -wut/worldUpType (below)for greater detail. If not given
            at creation time, the default value of (0.0, 1.0, 0.0) is used.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.aimConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GeometryConstraint(Constraint):
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.geometryConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.geometryConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.geometryConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.geometryConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrain an object's position based on the shape of the target surface(s) at
        the closest point(s) to the object. A geometryConstraint takes as input one or
        more surface shapes (the targets) and a DAG transform node (the object).  The
        geometryConstraint position constrained object such object lies on the surface
        of the target with the greatest weight value.  If two targets have the same
        weight value then the one with the lowest index is chosen.
        
        Flags:
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.geometryConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THimagePlane(ImagePlane):
    __melnode__ = []
    
    
    __readonly__ = {}


class EnvironmentFog(GeometryShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class TadskAssetInstanceNode_TlightShape(Light):
    __melnode__ = []
    
    
    __readonly__ = {}


class AnnotationShape(DimensionShape):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create an annotation to be attached to the specified
        objects at the specified point.
        
        Flags:
        - point : p                      (float, float, float) [create]
            Specifies the point about which the annotation text is to be centered.
        
        - text : tx                      (unicode)       [create]
            Specifies the annotation text.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.annotate`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'annotate'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveVarGroup(BaseGeometryVarGroup):
    __melnode__ = []
    
    
    __readonly__ = {}


class RelOverride(ValueOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformFlare(DeformFunc):
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderRect(GeometryShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class THdynSpring(Spring):
    __melnode__ = []
    
    
    __readonly__ = {}


class NurbsDimShape(DimensionShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class AbsOverride(ValueOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformBend(DeformFunc):
    __melnode__ = []
    
    
    __readonly__ = {}


class PointEmitter(DynBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AngleDimension(DimensionShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class PfxToon(PfxGeometry):
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformSine(DeformFunc):
    __melnode__ = []
    
    
    __readonly__ = {}


class GeometryVarGroup(BaseGeometryVarGroup):
    __melnode__ = []
    
    
    __readonly__ = {}


class StereoRigCamera(Camera):
    __melnode__ = []
    
    
    __readonly__ = {}


class DeformWave(DeformFunc):
    __melnode__ = []
    
    
    __readonly__ = {}


class LookAt(AimConstraint):
    __melnode__ = []
    
    
    __readonly__ = {}


class ControlPoint(DeformableShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class THassembly(Assembly):
    __melnode__ = []
    
    
    __readonly__ = {}


class CurveShape(DeformableShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class Particle(DeformableShape):
    def acceleration(self):
        """
        To return acceleration array for all particles.
        
        Returns:
        List['Vector']
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.acceleration`
        """
        pass
    def age(self, ages):
        """
        Populates the given array with the age values of the particles in this system.
        
        Parameters:
        ages : List['float']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.age`
        """
        pass
    def betterIllum(self):
        """
        Only for use with an MFnParticleSystem of renderType kCloud.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.betterIllum`
        """
        pass
    def castsShadows(self):
        """
        Returns whether or not the rendering attribute for particles casting shadows has been enabled.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.castsShadows`
        """
        pass
    def deformedParticleShape(self):
        """
        To get the deformed particleShape.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.deformedParticleShape`
        """
        pass
    def disableCloudAxis(self):
        """
        Only for use with an MFnParticleSystem of renderType kCloud.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.disableCloudAxis`
        """
        pass
    def emission(self, emissions):
        """
        Populates the given array with the incandescence values of the particles in this system, if the particles have this attribute. See hasEmission().
        
        Parameters:
        emissions : List['Vector']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.emission`
        """
        pass
    def emit(self, v):
        """
        To add a new particle at the given position.
        
        Parameters:
        v : 'Point'
            The particle's position
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.emit`
        """
        pass
    def evaluateDynamics(self, to, runupFromStart):
        """
        Run up the particle system to a certain frame, from either the current frame, or from the start of the simulation.
        
        Parameters:
        to : 'Time'
            Time to run the particle system up to.
        runupFromStart : 'bool'
            If true runup will begin at the start of the simulation, otherwise it will begin from the current frame.
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.evaluateDynamics`
        """
        pass
    def flatShaded(self):
        """
        To check if a particle shape of cloud type is flat shaded. This is only for use with an MFnParticleSystem of renderType kCloud.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.flatShaded`
        """
        pass
    def floatValue(self, val='True', **kwargs):
        """
        Used only in per particle attribute edit.  Specifies that the edit is of a float attribute and must be followed by the new float value.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the name of the attribute being queried or edited.       
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getCache(self, **kwargs):
        """
        Turns caching on/off for the particle shape.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getConserve(self, **kwargs):
        """
        Conservation of momentum control (between 0 and 1).  Specifies the fraction of the particle shape's existing momentum which is conserved from frame to frame. A value of 1 (the default) corresponds to true Newtonian physics, in which momentum is conserved.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getCount(self):
        """
        Returns the particle count at the current frame.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.count`
        """
        pass
    def getDynamicAttrList(self, **kwargs):
        """
        Returns a list of the dynamic attributes in the object.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getGridSpacing(self, **kwargs):
        """
        Spacing between particles in the grid.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getInherit(self, **kwargs):
        """
        Inherit this fraction (0-1) of emitting object's velocity.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getJitterBasePoint(self, **kwargs):
        """
        Base point (center point) for jitters.  The command will create one swatch of jitters for each base point.  It will pair up other flags with base points in the order they are given in the command line.  If not enough instances of the other flags are availble, the last one on the line with be used for all other instances of -jpb.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getJitterRadius(self, **kwargs):
        """
        Max radius from the center to place the particle instances.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getLowerLeft(self, **kwargs):
        """
        Lower left point of grid.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getNumJitters(self, **kwargs):
        """
        Number of jitters (instances) per particle.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getOrder(self, **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the zero-based order (index) of the particle whose attribute is being queried  or edited in the particle array. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getParticleId(self, **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the id of the particle whose attribute is being queried or edited. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getPerParticleAttribute(self, attrName):
        """
        To get per particle integer attribute with its attribute name.
        
        Parameters:
        attrName : 'unicode'
            The input attribute name
        
        
        Returns:
        Tuple['int', List['int']]
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.getPerParticleAttribute`
        """
        pass
    def getPerParticleDouble(self, **kwargs):
        """
        Returns a list of the per-particle double attributes, excluding initial-state, cache, and information-only attributes.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getPerParticleVector(self, **kwargs):
        """
        Returns a list of the per-particle vector attributes, excluding initial-state, cache, and information-only attributes.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getShapeName(self, **kwargs):
        """
        Specify the shape name used for geometry instancing. DO not confuse this with the -n flag which names the particle object.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def getUpperRight(self, **kwargs):
        """
        Upper right point of grid.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def hasEmission(self):
        """
        Returns whether or not the particles in this system have an emission attribute. See emission().
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.hasEmission`
        """
        pass
    def hasLifespan(self):
        """
        Returns whether or not the particles in this system have a lifespan attribute. See lifespan().
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.hasLifespan`
        """
        pass
    def hasOpacity(self):
        """
        Returns whether or not the particles in this system have an opacity attribute. See opacity().
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.hasOpacity`
        """
        pass
    def hasRgb(self):
        """
        Returns whether or not the particles in this system have an rgb attribute. See rgb().
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.hasRgb`
        """
        pass
    def isDeformedParticleShape(self):
        """
        To return if this particle shape is deformed.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.isDeformedParticleShape`
        """
        pass
    def isPerParticleDoubleAttribute(self, attrName):
        """
        To check if the input attribute is a per particle double attribute.
        
        Parameters:
        attrName : 'unicode'
            The input attribute name
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.isPerParticleDoubleAttribute`
        """
        pass
    def isPerParticleIntAttribute(self, attrName):
        """
        To check if the input attribute is a per particle integer attribute.
        
        Parameters:
        attrName : 'unicode'
            The input attribute name
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.isPerParticleIntAttribute`
        """
        pass
    def isPerParticleVectorAttribute(self, attrName):
        """
        To check if the input attribute is a per particle vector attribute.
        
        Parameters:
        attrName : 'unicode'
            The input attribute name
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.isPerParticleVectorAttribute`
        """
        pass
    def isValid(self):
        """
        Returns false if the particle array is nullptr.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.isValid`
        """
        pass
    def lifespan(self, lifespans):
        """
        Populates the given array with the lifespan values of the particles in this system, if the particles have this attribute. See hasLifespan().
        
        Parameters:
        lifespans : List['float']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.lifespan`
        """
        pass
    def mass(self):
        """
        To return mass array for all particles.
        
        Returns:
        List['float']
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.mass`
        """
        pass
    def num(self):
        """
        # for backwards compatibility, keep these two, even though the api wrap
        # will also provide 'count'
        """
        pass
    def opacity(self, opacities):
        """
        Populates the given array with the opacity values of the particles in this system, if the particles have this attribute. See hasOpacity().
        
        Parameters:
        opacities : List['float']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.opacity`
        """
        pass
    def originalParticleShape(self):
        """
        To get the original particleShape.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.originalParticleShape`
        """
        pass
    def particleIds(self):
        """
        Return an array of particle identifiers at the start of the time step. The array of particle id's is correlated with the other per-particle arrays returned by this class, so ids[i] will be the id for the particle with position position[i], velocity[i], etc., as long as all these arrays were retrieved for the same time step.
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.particleIds`
        """
        pass
    def particleName(self):
        """
        Returns the name of this particle system.
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.particleName`
        """
        pass
    def pointCount(self):
        """
        # for backwards compatibility, keep these two, even though the api wrap
        # will also provide 'count'
        """
        pass
    def position(self, positions):
        """
        Compute each particle's position at the start of the time step. This is done by taking the particle's current position and velocity, and extrapolation backwards in time.
        
        Parameters:
        positions : List['Vector']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.position`
        """
        pass
    def position0(self, positions):
        """
        Only for use with an MFnParticleSystem of renderType kTube.
        
        Parameters:
        positions : List['Vector']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.position0`
        """
        pass
    def position1(self, positions):
        """
        Only for use with an MFnParticleSystem of renderType kTube.
        
        Parameters:
        positions : List['Vector']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.position1`
        """
        pass
    def primaryVisibility(self):
        """
        Returns whether or not the rendering attribute for primary visibility in reflections has been enabled.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.primaryVisibility`
        """
        pass
    def radius(self, radii):
        """
        Calculates particle radii.
        
        Parameters:
        radii : List['float']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.radius`
        """
        pass
    def radius0(self, radii):
        """
        Only for use with an MFnParticleSystem of renderType kTube.
        
        Parameters:
        radii : List['float']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.radius0`
        """
        pass
    def radius1(self, radii):
        """
        Only for use with an MFnParticleSystem of renderType kTube.
        
        Parameters:
        radii : List['float']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.radius1`
        """
        pass
    def receiveShadows(self):
        """
        Returns whether or not the rendering attribute for particles receiving shadows has been enabled.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.receiveShadows`
        """
        pass
    def renderType(self):
        """
        Return the render type used by the particle object.
        
        Returns:
        'Particle.RenderType'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.renderType`
        """
        pass
    def rgb(self, colors):
        """
        Populates the given array with the color values of the particles in this system, if the particles have this attribute. See hasRgb().
        
        Parameters:
        colors : List['Vector']
            
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.rgb`
        """
        pass
    def saveInitialState(self):
        """
        To reset the particle's current state as the initial state.
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.saveInitialState`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the name of the attribute being queried or edited.       
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def setCache(self, val='True', **kwargs):
        """
        Turns caching on/off for the particle shape.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def setConserve(self, val='True', **kwargs):
        """
        Conservation of momentum control (between 0 and 1).  Specifies the fraction of the particle shape's existing momentum which is conserved from frame to frame. A value of 1 (the default) corresponds to true Newtonian physics, in which momentum is conserved.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def setCount(self, count):
        """
        Set the particle count at the current frame.
        
        Parameters:
        count : 'int'
            Particle count.
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.setCount`
        """
        pass
    def setInherit(self, val='True', **kwargs):
        """
        Inherit this fraction (0-1) of emitting object's velocity.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def setOrder(self, val='True', **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the zero-based order (index) of the particle whose attribute is being queried  or edited in the particle array. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def setParticleId(self, val='True', **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the id of the particle whose attribute is being queried or edited. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def setPerParticleAttribute(self, attrName, array):
        """
        To set the per particle vector attribute of the given name with the given values.
        
        Parameters:
        attrName : 'unicode'
            The input attribute name
        array : List['Vector']
            The input vector array
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.setPerParticleAttribute`
        """
        pass
    def setShapeName(self, val='True', **kwargs):
        """
        Specify the shape name used for geometry instancing. DO not confuse this with the -n flag which names the particle object.                  
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def surfaceShading(self):
        """
        Only for use with an MFnParticleSystem of renderType kCloud.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.surfaceShading`
        """
        pass
    def tailSize(self):
        """
        Only for use with an MFnParticleSystem of renderType kTube.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.tailSize`
        """
        pass
    def threshold(self):
        """
        Only for use with an MFnParticleSystem of renderType kCloud or kBlobby.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.threshold`
        """
        pass
    def vectorValue(self, val='True', **kwargs):
        """
        Used only in per particle attribute edit.  Specifies that the edit is of a vector attribute and must be followed by all three float values for the vector.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    def velocity(self):
        """
        To return velocity array for all particles.
        
        Returns:
        List['Vector']
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.velocity`
        """
        pass
    def visibleInReflections(self):
        """
        Returns whether or not the rendering attribute for particle visibility in reflections has been enabled.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.visibleInReflections`
        """
        pass
    def visibleInRefractions(self):
        """
        Returns whether or not the rendering attribute for particle visibility in refractions has been enabled.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnParticleSystem.visibleInRefractions`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The particle command creates a new particle object from a list of world space
        points. If a particle object is created, the command returns the names of the
        new particle shape and its associated particle object dependency node. If an
        object was queried, the results of the query are returned. Per particle
        attributes can be queried using the particleId or the order of the particle in
        the particle array. If an object was edited, nothing is returned.
        
        Flags:
        - attribute : at                 (unicode)       [query,edit]
            Used in per particle attribute query and edit. Specifies the name of the
            attribute being queried or edited.
        
        - cache : ch                     (bool)          [create,query,edit]
            Turns caching on/off for the particle shape.
        
        - conserve : c                   (float)         [query,edit]
            Conservation of momentum control (between 0 and 1).  Specifies the fraction of
            the particle shape's existing momentum which is conserved from frame to frame. A
            value of 1 (the default) corresponds to true Newtonian physics, in which
            momentum is conserved.
        
        - count : ct                     (bool)          [query]
            Returns the number of particles in the object.
        
        - deleteCache : dc               (bool)          [create]
            Deletes the particle shapes cache. This command is not undoable.
        
        - dynamicAttrList : dal          (bool)          [query]
            Returns a list of the dynamic attributes in the object.
        
        - floatValue : fv                (float)         [edit]
            Used only in per particle attribute edit.  Specifies that the edit is of a float
            attribute and must be followed by the new float value.
        
        - gridSpacing : grs              (float)         [create,query]
            Spacing between particles in the grid.
        
        - inherit : i                    (float)         [query,edit]
            Inherit this fraction (0-1) of emitting object's velocity.
        
        - jitterBasePoint : jbp          (float, float, float) [create,query]
            Base point (center point) for jitters.  The command will create one swatch of
            jitters for each base point.  It will pair up other flags with base points in
            the order they are given in the command line.  If not enough instances of the
            other flags are availble, the last one on the line with be used for all other
            instances of -jpb.
        
        - jitterRadius : jr              (float)         [create,query]
            Max radius from the center to place the particle instances.
        
        - lowerLeft : ll                 (float, float, float) [create,query]
            Lower left point of grid.
        
        - name : n                       (unicode)       [query,edit]
            name of particle object
        
        - numJitters : nj                (int)           [create,query]
            Number of jitters (instances) per particle.
        
        - order : order                  (int)           [query,edit]
            Used in per particle attribute query and edit. Specifies the zero-based order
            (index) of the particle whose attribute is being queried  or edited in the
            particle array. Querying the value of a per particle attribute requires the
            -attribute and -id or -order flags and their arguments to precede the -q flag.
        
        - particleId : id                (int)           [query,edit]
            Used in per particle attribute query and edit. Specifies the id of the particle
            whose attribute is being queried or edited. Querying the value of a per particle
            attribute requires the -attribute and -id or -order flags and their arguments to
            precede the -q flag.
        
        - perParticleDouble : ppd        (bool)          [query]
            Returns a list of the per-particle double attributes, excluding initial-state,
            cache, and information-only attributes.
        
        - perParticleVector : ppv        (bool)          [query]
            Returns a list of the per-particle vector attributes, excluding initial-state,
            cache, and information-only attributes.
        
        - position : p                   (float, float, float) []
            World-space position of each particle.
        
        - shapeName : sn                 (unicode)       [query,edit]
            Specify the shape name used for geometry instancing. DO not confuse this with
            the -n flag which names the particle object.
        
        - upperRight : ur                (float, float, float) [create,query]
            Upper right point of grid.
        
        - vectorValue : vv               (float, float, float) [edit]
            Used only in per particle attribute edit.  Specifies that the edit is of a
            vector attribute and must be followed by all three float values for the vector.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.particle`
        """
        pass
    Point = None
    
    
    RenderType = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DragField(Field):
    def getDirection(self):
        """
        Returns the direction of the drag force's influence along the x, y, and z axes. You must have the Use Direction setting turned on for this attribute to take effect.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnDragField.direction`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        X-component of direction.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        Y-component of direction.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        Z-component of direction                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def getUseDirection(self):
        """
        Returns true if the braking force is exerted only against the component of the object's velocity that lies along the direction of the drag force.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnDragField.useDirection`
        """
        pass
    def getVolumeExclusion(self, **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setDirection(self, dragDirection):
        """
        Sets the direction of the drag force's influence along the x, y, and z axes. You must have the Use Direction setting turned on for this attribute to take effect.
        
        Parameters:
        dragDirection : 'Vector'
            A vector representing direction.
        
        Derived from api method `maya.OpenMayaFX.MFnDragField.setDirection`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        X-component of direction.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        Y-component of direction.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        Z-component of direction                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setUseDirection(self, enable):
        """
        Enables the braking force to be exerted only against the component of the object's velocity that lies along the direction setting of the drag force.
        
        Parameters:
        enable : 'bool'
            Flag to enable or disable direction setting.
        
        Derived from api method `maya.OpenMayaFX.MFnDragField.setUseDirection`
        """
        pass
    def setVolumeExclusion(self, val='True', **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        For each listed object, the command creates a new field. The field has a shape
        which lives in the DAG and it has an associated dependency node. The field is
        added to the list of fields owned by the object. Use connectDynamic to cause the
        field to affect a dynamic object. Note that if more than one object is listed, a
        separate field is created for each object. If fields are created, this command
        returns the names of each owning shape and of the field shapes themselves. If a
        field was queried, the results of the query are returned. If a field was edited,
        the field name is returned. If no object names are provided but the active
        selection list is non-empty, the command creates a field for every object in the
        list. If the list is empty, the command defaults to -pos 0 0 0. Drag exerts a
        friction, or braking force proportional to the speed of a moving object. If
        direction is not enabled, the drag acts opposite to the current velocity of the
        object. If direction is enabled, it acts opposite to the component of the
        velocity in the specified direction. The force is independent of the position of
        the affected object. The transform is the associated dependency node. Use
        connectDynamic to cause the field to affect a dynamic object. If fields are
        created, this command returns the names of each of the fields. If a field was
        queried, the results of the query are returned. If a field was edited, the field
        name is returned. If object names are provided or the active selection list is
        non-empty, the command creates a field for every object in the list and calls
        addDynamic to add it to the object. If the list is empty, the command defaults
        to -pos 0 0 0. Setting the -pos flag with objects named on the command line is
        an error.
        
        Flags:
        - attenuation : att              (float)         [query,edit]
            Attentuation rate of field
        
        - directionX : dx                (float)         [query,edit]
            X-component of direction.
        
        - directionY : dy                (float)         [query,edit]
            Y-component of direction.
        
        - directionZ : dz                (float)         [query,edit]
            Z-component of direction
        
        - magnitude : m                  (float)         [query,edit]
            Strength of field.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which field is exerted. -1 indicates that the field has no
            maximum distance.
        
        - name : n                       (unicode)       [query,edit]
            name of field
        
        - perVertex : pv                 (bool)          [query,edit]
            Per-vertex application. If this flag is set true, then each individual point
            (CV, particle, vertex,etc.) of the chosen object exerts an identical copy of the
            force field. If this flag is set to false, then the froce is exerted only from
            the geometric center of the set of points.
        
        - position : pos                 (float, float, float) [query,edit]
            Position in space (x,y,z) where you want to place a gravity field. The gravity
            then emanates from this position in space rather than from an object. Note that
            you can both use -pos (creating a field at a position) and also provide object
            names.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - useDirection : ud              (bool)          [query,edit]
            Enable/disable direction. Drag will use -dx/-dy/-dz arguments if and only if
            this flag is set true.
        
        - volumeExclusion : vex          (bool)          [query,edit]
            Volume exclusion of the field.  If true, points outside the volume (defined by
            the volume shape attribute) are affected,  If false, points inside the volume
            are affected.  Has no effect if volumeShape is set to none.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the field.  Volume offset translates the field's volume by the
            specified amount from the actual field location. This is in the field's local
            space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the field.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.drag`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'drag'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PoleVectorConstraint(PointConstraint):
    def getTargetList(self, **kwargs):
        """
        Return the list of target objects.                  
        
        
        Derived from mel command `maya.cmds.poleVectorConstraint`
        """
        pass
    def getWeightAliasList(self, **kwargs):
        """
        Returns the names of the attributes that control the weight of the target objects. Aliases are returned in the same order as the targets are returned by the targetList flag                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.poleVectorConstraint`
        """
        pass
    def layer(self, val='True', **kwargs):
        """
        Specify the name of the animation layer where the constraint should be added.                  
        
        
        Derived from mel command `maya.cmds.poleVectorConstraint`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        removes the listed target(s) from the constraint.                  
        
        
        Derived from mel command `maya.cmds.poleVectorConstraint`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Constrains the poleVector of an ikRPsolve handle to point at a target object or
        at the average position of a number of targets. An poleVectorConstraint takes as
        input one or more targetDAG transform nodes at which to aim pole vector for an
        IK handle using the rotate plane solver.  The pole vector is adjust such that
        the in weighted average of the world space position target objects lies is the
        rotate planeof the handle.
        
        Flags:
        - layer : l                      (unicode)       [create,edit]
            Specify the name of the animation layer where the constraint should be added.
        
        - name : n                       (unicode)       [create,query,edit]
            Sets the name of the constraint node to the specified name.  Default name is
            constrainedObjectName_constraintType
        
        - remove : rm                    (bool)          [edit]
            removes the listed target(s) from the constraint.
        
        - targetList : tl                (bool)          [query]
            Return the list of target objects.
        
        - weight : w                     (float)         [create,query,edit]
            Sets the weight value for the specified target(s). If not given at creation
            time, the default value of 1.0 is used.
        
        - weightAliasList : wal          (bool)          [query]
            Returns the names of the attributes that control the weight of the target
            objects. Aliases are returned in the same order as the targets are returned by
            the targetList flag                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.poleVectorConstraint`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderCone(ImplicitCone):
    __melnode__ = []
    
    
    __readonly__ = {}


class THdynField(Field):
    __melnode__ = []
    
    
    __readonly__ = {}


class NewtonField(Field):
    def getMinDistance(self):
        """
        Returns the minimum distance from the newton field at which the force of the field is exerted.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnNewtonField.minDistance`
        """
        pass
    def setMinDistance(self, distance):
        """
        Sets the minimum distance from the newton field at which the force of the field is exerted.
        
        Parameters:
        distance : 'float'
            A value representing distance in internal linear units.
        
        Derived from api method `maya.OpenMayaFX.MFnNewtonField.setMinDistance`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class VortexField(Field):
    def getAxis(self):
        """
        Returns the axis around which the vortex field exerts it's force.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnVortexField.axis`
        """
        pass
    def getAxisX(self, **kwargs):
        """
        X-component of vortex axis                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def getAxisY(self, **kwargs):
        """
        Y-component of vortex axis                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def getAxisZ(self, **kwargs):
        """
        Z-component of vortex axis                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def getVolumeExclusion(self, **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setAxis(self, axisVector):
        """
        Sets the axis around which the vortex field exerts it's force.
        
        Parameters:
        axisVector : 'Vector'
            A vector representing an axis.
        
        Derived from api method `maya.OpenMayaFX.MFnVortexField.setAxis`
        """
        pass
    def setAxisX(self, val='True', **kwargs):
        """
        X-component of vortex axis                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setAxisY(self, val='True', **kwargs):
        """
        Y-component of vortex axis                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setAxisZ(self, val='True', **kwargs):
        """
        Z-component of vortex axis                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setVolumeExclusion(self, val='True', **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        For each listed object, the command creates a new field. The field has a shape
        which lives in the DAG and it has an associated dependency node. The field is
        added to the list of fields owned by the object. Use connectDynamic to cause the
        field to affect a dynamic object. Note that if more than one object is listed, a
        separate field is created for each object. If fields are created, this command
        returns the names of each owning shape and of the field shapes themselves. If a
        field was queried, the results of the query are returned. If a field was edited,
        the field name is returned. If no object names are provided but the active
        selection list is non-empty, the command creates a field for every object in the
        list. If the list is empty, the command defaults to -pos 0 0 0. A vortex field
        pulls objects in a circular direction, like a whirlpool or tornado.   Objects
        affected by the vortex field tend to rotate around the axis specified by -ax,
        -ay, and -az. The transform is the associated dependency node. Use
        connectDynamic to cause the field to affect a dynamic object. If fields are
        created, this command returns the names of each of the fields. If a field was
        queried, the results of the query are returned. If a field was edited, the field
        name is returned. If object names are provided or the active selection list is
        non-empty, the command creates a field for every object in the list and calls
        addDynamic to add it to the object. If the list is empty, the command defaults
        to -pos 0 0 0. Setting the -pos flag with objects named on the command line is
        an error.
        
        Flags:
        - attenuation : att              (float)         [query,edit]
            Attentuation rate of field
        
        - axisX : ax                     (float)         [query,edit]
            X-component of vortex axis
        
        - axisY : ay                     (float)         [query,edit]
            Y-component of vortex axis
        
        - axisZ : az                     (float)         [query,edit]
            Z-component of vortex axis
        
        - magnitude : m                  (float)         [query,edit]
            Strength of field.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which field is exerted. -1 indicates that the field has no
            maximum distance.
        
        - name : n                       (unicode)       [query,edit]
            name of field
        
        - perVertex : pv                 (bool)          [query,edit]
            Per-vertex application. If this flag is set true, then each individual point
            (CV, particle, vertex,etc.) of the chosen object exerts an identical copy of the
            force field. If this flag is set to false, then the froce is exerted only from
            the geometric center of the set of points.
        
        - position : pos                 (float, float, float) [query,edit]
            Position in space (x,y,z) where you want to place a gravity field. The gravity
            then emanates from this position in space rather than from an object. Note that
            you can both use -pos (creating a field at a position) and also provide object
            names.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - volumeExclusion : vex          (bool)          [query,edit]
            Volume exclusion of the field.  If true, points outside the volume (defined by
            the volume shape attribute) are affected,  If false, points inside the volume
            are affected.  Has no effect if volumeShape is set to none.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the field.  Volume offset translates the field's volume by the
            specified amount from the actual field location. This is in the field's local
            space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the field.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.vortex`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'vortex'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderSphere(ImplicitSphere):
    __melnode__ = []
    
    
    __readonly__ = {}


class AmbientLight(RenderLight):
    def getAmbientShade(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnAmbientLight.ambientShade`
        """
        pass
    def getCastSoftShadows(self):
        """
        Retrieves the value of the "castSoftShadows" attribute of an ambient light node. This attribute determines whether or not the light casts soft shadows.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnAmbientLight.castSoftShadows`
        """
        pass
    def getDiscRadius(self, **kwargs):
        """
        radius of the disc around the light                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        True if the light is exclusively assigned                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def getPosition(self, **kwargs):
        """
        Position of the light                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def getRgb(self, **kwargs):
        """
        RGB colour of the light                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def getRotation(self, **kwargs):
        """
        Rotation of the light for orientation, where applicable                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def getShadowDither(self, **kwargs):
        """
        dither the shadow                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def getShadowRadius(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnAmbientLight.shadowRadius`
        """
        pass
    def getShadowSamples(self, **kwargs):
        """
        number of shadow samples.                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def getSoftShadow(self, **kwargs):
        """
        soft shadow                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def setAmbientShade(self, ambient_shade):
        """
        Sets the value of the "ambientShade" attribute of an ambient light node.
        
        Parameters:
        ambient_shade : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAmbientLight.setAmbientShade`
        """
        pass
    def setCastSoftShadows(self, cast_soft_shadows):
        """
        Sets the value of the "castSoftShadows" attribute of an ambient light node.
        
        Parameters:
        cast_soft_shadows : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAmbientLight.setCastSoftShadows`
        """
        pass
    def setDiscRadius(self, val='True', **kwargs):
        """
        radius of the disc around the light                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def setShadowDither(self, val='True', **kwargs):
        """
        dither the shadow                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def setShadowRadius(self, shadow_radius):
        """
        Sets the value of the "shadowRadius" attribute of an ambient light node.
        
        Parameters:
        shadow_radius : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnAmbientLight.setShadowRadius`
        """
        pass
    def setShadowSamples(self, val='True', **kwargs):
        """
        number of shadow samples.                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    def setSoftShadow(self, val='True', **kwargs):
        """
        soft shadow                  
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        TlightCmd is the base class for other light commands. The ambientLight command
        is used to edit the parameters of existing ambientLights, or to create new ones.
        The default behaviour is to create a new ambientlight. This is the commmand that
        instantiates an ambientLight or edits the parameters of an existing one.
        TambientLightCmd inherits from TlightCmd which defines common flags like
        intensity, colour etc. See TlightCmd for a global picture of the light commands.
        Note that the flag fAmbientLightUsed indicates whether the command uses any
        ambient specific flags. That is, if a command doesn't use flags defined here,
        the boolean fAmbientLightUsed is set to false and thus the undo/redo information
        is not saved at this level. TambientLightCmd behaves like any other command, it
        has flags, saves undo information etc. the only slightly different behaviour is
        that it calls up to TlightCmd to complete the functionality of the command.
        Example      parseArgs:  TambientLightCmd defines ambientLight specific
        parameters like -ambientShade however, several other parameters are available in
        TlightCmd such as -intensity etc.  So when parsing the arguments, a call is made
        to TlightCmd::parseArgs to parse common parameters (like Intensity).
        
        Flags:
        - ambientShade : ambientShade    (float)         [create,query,edit]
            ambientShade
        
        - discRadius : drs               (float)         [create,query,edit]
            radius of the disc around the light
        
        - exclusive : exc                (bool)          [create,query]
            True if the light is exclusively assigned
        
        - intensity : i                  (float)         [create,query]
            Intensity of the light
        
        - name : n                       (unicode)       [create,query]
            Name of the light
        
        - position : pos                 (float, float, float) [create,query]
            Position of the light
        
        - rgb : rgb                      (float, float, float) [create,query]
            RGB colour of the light
        
        - rotation : rot                 (float, float, float) [create,query]
            Rotation of the light for orientation, where applicable
        
        - shadowColor : sc               (float, float, float) [create,query]
            Color of the light's shadow
        
        - shadowDither : sd              (float)         [create,query,edit]
            dither the shadow
        
        - shadowSamples : sh             (int)           [create,query,edit]
            number of shadow samples.
        
        - softShadow : ss                (bool)          [create,query,edit]
            soft shadow
        
        - useRayTraceShadows : rs        (bool)          [create,query]
            True if ray trace shadows are to be used                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.ambientLight`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class UniformField(Field):
    def getDirection(self):
        """
        Returns the direction the uniform field pushes objects.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnUniformField.direction`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        X-component of direction.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        Y-component of direction.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        Z-component of direction                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def getVolumeExclusion(self, **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setDirection(self, uniformDirection):
        """
        Sets the direction the uniform field pushes objects.
        
        Parameters:
        uniformDirection : 'Vector'
            A vector representing direction.
        
        Derived from api method `maya.OpenMayaFX.MFnUniformField.setDirection`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        X-component of direction.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        Y-component of direction.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        Z-component of direction                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setVolumeExclusion(self, val='True', **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        For each listed object, the command creates a new field. The field has a shape
        which lives in the DAG and it has an associated dependency node. The field is
        added to the list of fields owned by the object. Use connectDynamic to cause the
        field to affect a dynamic object. Note that if more than one object is listed, a
        separate field is created for each object. If fields are created, this command
        returns the names of each owning shape and of the field shapes themselves. If a
        field was queried, the results of the query are returned. If a field was edited,
        the field name is returned. If no object names are provided but the active
        selection list is non-empty, the command creates a field for every object in the
        list. If the list is empty, the command defaults to -pos 0 0 0. A uniform field
        pushes objects in a fixed direction.  The field strength, but not the field
        direction, depends on the distance from the object to the field location. The
        transform is the associated dependency node. Use connectDynamic to cause the
        field to affect a dynamic object. If fields are created, this command returns
        the names of each of the fields. If a field was queried, the results of the
        query are returned. If a field was edited, the field name is returned. If object
        names are provided or the active selection list is non-empty, the command
        creates a field for every object in the list and calls addDynamic to add it to
        the object. If the list is empty, the command defaults to -pos 0 0 0. Setting
        the -pos flag with objects named on the command line is an error.
        
        Flags:
        - attenuation : att              (float)         [query,edit]
            Attentuation rate of field
        
        - directionX : dx                (float)         [query,edit]
            X-component of direction.
        
        - directionY : dy                (float)         [query,edit]
            Y-component of direction.
        
        - directionZ : dz                (float)         [query,edit]
            Z-component of direction
        
        - magnitude : m                  (float)         [query,edit]
            Strength of field.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which field is exerted. -1 indicates that the field has no
            maximum distance.
        
        - name : n                       (unicode)       [query,edit]
            name of field
        
        - perVertex : pv                 (bool)          [query,edit]
            Per-vertex application. If this flag is set true, then each individual point
            (CV, particle, vertex,etc.) of the chosen object exerts an identical copy of the
            force field. If this flag is set to false, then the froce is exerted only from
            the geometric center of the set of points.
        
        - position : pos                 (float, float, float) [query,edit]
            Position in space (x,y,z) where you want to place a gravity field. The gravity
            then emanates from this position in space rather than from an object. Note that
            you can both use -pos (creating a field at a position) and also provide object
            names.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - volumeExclusion : vex          (bool)          [query,edit]
            Volume exclusion of the field.  If true, points outside the volume (defined by
            the volume shape attribute) are affected,  If false, points inside the volume
            are affected.  Has no effect if volumeShape is set to none.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the field.  Volume offset translates the field's volume by the
            specified amount from the actual field location. This is in the field's local
            space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the field.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.uniform`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'uniform'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyChipOff(PolyMoveFace):
    def getAttraction(self, **kwargs):
        """
        Attraction, related to magnet. The range is [-2.0, 2.0]. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getCaching(self, **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getConstructionHistory(self, **kwargs):
        """
        Turn the construction history on or off (where applicable). If construction history is on then the corresponding node will be inserted into the history chain for the mesh. If construction history is off then the operation will be performed directly on the object. Note:If the object already has construction history then this flag is ignored and the node will always be inserted into the history chain.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getDuplicate(self, **kwargs):
        """
        If on, facets are duplicated, otherwise original facets are removed. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getGain(self, **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getGravity(self, **kwargs):
        """
        The gravity vector. Default:0.0, -1.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getGravityX(self, **kwargs):
        """
        Gravity X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getGravityY(self, **kwargs):
        """
        Gravity Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getGravityZ(self, **kwargs):
        """
        Gravity Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getKeepFacesTogether(self, **kwargs):
        """
        How to extrude edges. If on, extruded faces produced from the edges being extruded will be kept together. Otherwise they are pulled independently. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getKeepFacetTogether(self, **kwargs):
        """
        How to extrude edges. If on, extruded faces produced from the edges being extruded will be kept together. Otherwise they are pulled independently. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalCenter(self, **kwargs):
        """
        Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalDirection(self, **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalDirectionX(self, **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalDirectionY(self, **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalDirectionZ(self, **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalRotate(self, **kwargs):
        """
        The local rotations. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalRotateX(self, **kwargs):
        """
        Local rotate X coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalRotateY(self, **kwargs):
        """
        Local rotate Y coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalRotateZ(self, **kwargs):
        """
        Local rotate Z coord : Rotation along the normal. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalScale(self, **kwargs):
        """
        Local Scale. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalScaleX(self, **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalScaleY(self, **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalScaleZ(self, **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalTranslate(self, **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalTranslateX(self, **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalTranslateY(self, **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getLocalTranslateZ(self, **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getMagnX(self, **kwargs):
        """
        Magnet X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getMagnY(self, **kwargs):
        """
        Magnet Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getMagnZ(self, **kwargs):
        """
        Magnet Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getMagnet(self, **kwargs):
        """
        The magnet vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getNodeState(self, **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getOffset(self, **kwargs):
        """
        Local offset. Faces are moved this distance towards the inside of the face. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getPivot(self, **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getPivotX(self, **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getPivotY(self, **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getPivotZ(self, **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getRandom(self, **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getScale(self, **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getScaleX(self, **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getScaleY(self, **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getScaleZ(self, **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getTranslate(self, **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getTranslateX(self, **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getTranslateY(self, **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getTranslateZ(self, **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getWeight(self, **kwargs):
        """
        The weight, related to gravity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def getWorldSpace(self, **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setAttraction(self, val='True', **kwargs):
        """
        Attraction, related to magnet. The range is [-2.0, 2.0]. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setCaching(self, val='True', **kwargs):
        """
        Toggle caching for all attributes so that no recomputation is needed                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setDuplicate(self, val='True', **kwargs):
        """
        If on, facets are duplicated, otherwise original facets are removed. C: Default is on. Q: When queried, this flag returns an int.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setGain(self, val='True', **kwargs):
        """
        Gain factor per component. Can be painted using Artisan. Default:1.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setGravity(self, val='True', **kwargs):
        """
        The gravity vector. Default:0.0, -1.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setGravityX(self, val='True', **kwargs):
        """
        Gravity X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setGravityY(self, val='True', **kwargs):
        """
        Gravity Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setGravityZ(self, val='True', **kwargs):
        """
        Gravity Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setKeepFacesTogether(self, val='True', **kwargs):
        """
        How to extrude edges. If on, extruded faces produced from the edges being extruded will be kept together. Otherwise they are pulled independently. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setKeepFacetTogether(self, val='True', **kwargs):
        """
        How to extrude edges. If on, extruded faces produced from the edges being extruded will be kept together. Otherwise they are pulled independently. Default:true                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalCenter(self, val='True', **kwargs):
        """
        Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalDirection(self, val='True', **kwargs):
        """
        Direction to determine X axis for local space. Default:1.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalDirectionX(self, val='True', **kwargs):
        """
        X coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalDirectionY(self, val='True', **kwargs):
        """
        Y coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalDirectionZ(self, val='True', **kwargs):
        """
        Z coord of the X axis.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalRotate(self, val='True', **kwargs):
        """
        The local rotations. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalRotateX(self, val='True', **kwargs):
        """
        Local rotate X coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalRotateY(self, val='True', **kwargs):
        """
        Local rotate Y coord. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalRotateZ(self, val='True', **kwargs):
        """
        Local rotate Z coord : Rotation along the normal. The range is [0, 360].                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalScale(self, val='True', **kwargs):
        """
        Local Scale. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalScaleX(self, val='True', **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalScaleY(self, val='True', **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalScaleZ(self, val='True', **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalTranslate(self, val='True', **kwargs):
        """
        Local translate. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalTranslateX(self, val='True', **kwargs):
        """
        Local translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalTranslateY(self, val='True', **kwargs):
        """
        Local translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setLocalTranslateZ(self, val='True', **kwargs):
        """
        Local translation Z coord : Move along the normal.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setMagnX(self, val='True', **kwargs):
        """
        Magnet X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setMagnY(self, val='True', **kwargs):
        """
        Magnet Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setMagnZ(self, val='True', **kwargs):
        """
        Magnet Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setMagnet(self, val='True', **kwargs):
        """
        The magnet vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setNodeState(self, val='True', **kwargs):
        """
        Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1), and Blocking (2)states can be used to alter how the graph is evaluated.   The Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for internal use only. They temporarily shut off parts of the graph during interaction (e.g., manipulation). The understanding is that once the operation is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset back to Blocking.   The Normaland Blockingcases apply to all nodes, while HasNoEffectis node specific; many nodes do not support this option. Plug-ins store state in the MPxNode::stateattribute. Anyone can set it or check this attribute.  Additional details about each of these 3 states follow.  StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an operation on an input producing an output of the same data type. Nearly all deformers support this state, as do a few other nodes. As stated earlier, it is not supported by all nodes.  Its typical to implement support for the HasNoEffectstate in the nodes compute method and to perform appropriate operations. Plug-ins can also support HasNoEffect.  The usual implementation of this state is to copy the input directly to the matching output without applying the algorithm in the node. For deformers, applying this state leaves the input geometry undeformed on the output.  BlockingThis is implemented in the depend node base class and applies to all nodes. Blockingis applied during the evaluation phase to connections. An evaluation request to a blocked connection will return as failures, causing the destination plug to retain its current value. Dirty propagation is indirectly affected by this state since blocked connections are never cleaned.  When a node is set to Blockingthe behavior is supposed to be the same as if all outgoing connections were broken. As long as nobody requests evaluation of the blocked node directly it wont evaluate after that. Note that a blocked node will still respond to getAttrrequests but a getAttron a downstream node will not reevaluate the blocked node.  Setting the root transform of a hierarchy to Blockingwont automatically influence child transforms in the hierarchy. To do this, youd need to explicitly set all child nodes to the Blockingstate.  For example, to set all child transforms to Blocking, you could use the following script.  import maya.cmds as cmds def blockTree(root): nodesToBlock = [] for node in {child:1 for child in cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock += cmds.listConnections(node, source=True, destination=True ) for node in {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' % node, 2 )  Applying this script would continue to draw objects but things would not be animated.  Default:kdnNormal                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setOffset(self, val='True', **kwargs):
        """
        Local offset. Faces are moved this distance towards the inside of the face. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setPivot(self, val='True', **kwargs):
        """
        The pivot for scaling and rotation. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setPivotX(self, val='True', **kwargs):
        """
        Pivot X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setPivotY(self, val='True', **kwargs):
        """
        Pivot Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setPivotZ(self, val='True', **kwargs):
        """
        Pivot Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setRandom(self, val='True', **kwargs):
        """
        Random value for all parameters. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setScale(self, val='True', **kwargs):
        """
        Scaling vector. Default:1.0, 1.0, 1.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setScaleX(self, val='True', **kwargs):
        """
        Scale X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setScaleY(self, val='True', **kwargs):
        """
        Scale Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setScaleZ(self, val='True', **kwargs):
        """
        Scale Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setTranslate(self, val='True', **kwargs):
        """
        Translation vector. Default:0.0, 0.0, 0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setTranslateX(self, val='True', **kwargs):
        """
        Translation X coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setTranslateY(self, val='True', **kwargs):
        """
        Translation Y coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setTranslateZ(self, val='True', **kwargs):
        """
        Translation Z coord.                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setWeight(self, val='True', **kwargs):
        """
        The weight, related to gravity. Default:0.0                  
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    def setWorldSpace(self, val='True', **kwargs):
        """
        This flag specifies which reference to use. If on: all geometrical values are taken in world reference. If off: all geometrical values are taken in object reference. C: Default is off. Q: When queried, this flag returns an int.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Extract facets. Faces can be extracted separately or together, and manipulations
        can be performed either in world or object space.
        
        Flags:
        - attraction : att               (float)         [create,query,edit]
            Attraction, related to magnet. The range is [-2.0, 2.0]. Default:0.0
        
        - caching : cch                  (bool)          [create,query,edit]
            Toggle caching for all attributes so that no recomputation is needed
        
        - constructionHistory : ch       (bool)          [create,query]
            Turn the construction history on or off (where applicable). If construction
            history is on then the corresponding node will be inserted into the history
            chain for the mesh. If construction history is off then the operation will be
            performed directly on the object. Note:If the object already has construction
            history then this flag is ignored and the node will always be inserted into the
            history chain.
        
        - duplicate : dup                (bool)          [create,query,edit]
            If on, facets are duplicated, otherwise original facets are removed. C: Default
            is on. Q: When queried, this flag returns an int.
        
        - frozen : fzn                   (bool)          []
        
        - gain : ga                      (float)         [create,query,edit]
            Gain factor per component. Can be painted using Artisan. Default:1.0
        
        - gravity : g                    (float, float, float) [create,query,edit]
            The gravity vector. Default:0.0, -1.0, 0.0
        
        - gravityX : gx                  (float)         [create,query,edit]
            Gravity X coord.
        
        - gravityY : gy                  (float)         [create,query,edit]
            Gravity Y coord.
        
        - gravityZ : gz                  (float)         [create,query,edit]
            Gravity Z coord.
        
        - keepFacesTogether : kft        (bool)          [create,query,edit]
            How to extrude edges. If on, extruded faces produced from the edges being
            extruded will be kept together. Otherwise they are pulled independently.
            Default:true
        
        - keepFacetTogether : xft        (bool)          [create,query,edit]
            How to extrude edges. If on, extruded faces produced from the edges being
            extruded will be kept together. Otherwise they are pulled independently.
            Default:true
        
        - localCenter : lc               (int)           [create,query,edit]
            Local center on the edge : 0=Middle point, 1=Start point, 2=End point. Default:0
        
        - localDirection : ld            (float, float, float) [create,query,edit]
            Direction to determine X axis for local space. Default:1.0, 0.0, 0.0
        
        - localDirectionX : ldx          (float)         [create,query,edit]
            X coord of the X axis.
        
        - localDirectionY : ldy          (float)         [create,query,edit]
            Y coord of the X axis.
        
        - localDirectionZ : ldz          (float)         [create,query,edit]
            Z coord of the X axis.
        
        - localRotate : lr               (float, float, float) [create,query,edit]
            The local rotations. Default:0.0, 0.0, 0.0
        
        - localRotateX : lrx             (float)         [create,query,edit]
            Local rotate X coord. The range is [0, 360].
        
        - localRotateY : lry             (float)         [create,query,edit]
            Local rotate Y coord. The range is [0, 360].
        
        - localRotateZ : lrz             (float)         [create,query,edit]
            Local rotate Z coord : Rotation along the normal. The range is [0, 360].
        
        - localScale : ls                (float, float, float) [create,query,edit]
            Local Scale. Default:1.0, 1.0, 1.0
        
        - localScaleX : lsx              (float)         [create,query,edit]
            Scale X coord.
        
        - localScaleY : lsy              (float)         [create,query,edit]
            Scale Y coord.
        
        - localScaleZ : lsz              (float)         [create,query,edit]
            Scale Z coord.
        
        - localTranslate : lt            (float, float, float) [create,query,edit]
            Local translate. Default:0.0, 0.0, 0.0
        
        - localTranslateX : ltx          (float)         [create,query,edit]
            Local translation X coord.
        
        - localTranslateY : lty          (float)         [create,query,edit]
            Local translation Y coord.
        
        - localTranslateZ : ltz          (float)         [create,query,edit]
            Local translation Z coord : Move along the normal.
        
        - magnX : mx                     (float)         [create,query,edit]
            Magnet X coord.
        
        - magnY : my                     (float)         [create,query,edit]
            Magnet Y coord.
        
        - magnZ : mz                     (float)         [create,query,edit]
            Magnet Z coord.
        
        - magnet : m                     (float, float, float) [create,query,edit]
            The magnet vector. Default:0.0, 0.0, 0.0
        
        - name : n                       (unicode)       [create]
            Give a name to the resulting node.
        
        - nodeState : nds                (int)           [create,query,edit]
            Maya dependency nodes have 6 possible states. The Normal (0), HasNoEffect (1),
            and Blocking (2)states can be used to alter how the graph is evaluated.   The
            Waiting-Normal (3), Waiting-HasNoEffect (4), Waiting-Blocking (5)are for
            internal use only. They temporarily shut off parts of the graph during
            interaction (e.g., manipulation). The understanding is that once the operation
            is done, the state will be reset appropriately, e.g. Waiting-Blockingwill reset
            back to Blocking.   The Normaland Blockingcases apply to all nodes, while
            HasNoEffectis node specific; many nodes do not support this option. Plug-ins
            store state in the MPxNode::stateattribute. Anyone can set it or check this
            attribute.  Additional details about each of these 3 states follow.
            StateDescriptionNormalThe normal node state. This is the default.HasNoEffectThe
            HasNoEffectoption (a.k.a. pass-through), is used in cases where there is an
            operation on an input producing an output of the same data type. Nearly all
            deformers support this state, as do a few other nodes. As stated earlier, it is
            not supported by all nodes.  Its typical to implement support for the
            HasNoEffectstate in the nodes compute method and to perform appropriate
            operations. Plug-ins can also support HasNoEffect.  The usual implementation of
            this state is to copy the input directly to the matching output without applying
            the algorithm in the node. For deformers, applying this state leaves the input
            geometry undeformed on the output.  BlockingThis is implemented in the depend
            node base class and applies to all nodes. Blockingis applied during the
            evaluation phase to connections. An evaluation request to a blocked connection
            will return as failures, causing the destination plug to retain its current
            value. Dirty propagation is indirectly affected by this state since blocked
            connections are never cleaned.  When a node is set to Blockingthe behavior is
            supposed to be the same as if all outgoing connections were broken. As long as
            nobody requests evaluation of the blocked node directly it wont evaluate after
            that. Note that a blocked node will still respond to getAttrrequests but a
            getAttron a downstream node will not reevaluate the blocked node.  Setting the
            root transform of a hierarchy to Blockingwont automatically influence child
            transforms in the hierarchy. To do this, youd need to explicitly set all child
            nodes to the Blockingstate.  For example, to set all child transforms to
            Blocking, you could use the following script.  import maya.cmds as cmds def
            blockTree(root): nodesToBlock = [] for node in {child:1 for child in
            cmds.listRelatives( root, path=True, allDescendents=True )}.keys(): nodesToBlock
            += cmds.listConnections(node, source=True, destination=True ) for node in
            {source:1 for source in nodesToBlock}.keys(): cmds.setAttr( '%s.nodeState' %
            node, 2 )  Applying this script would continue to draw objects but things would
            not be animated.  Default:kdnNormal
        
        - offset : off                   (float)         [create,query,edit]
            Local offset. Faces are moved this distance towards the inside of the face.
            Default:0.0
        
        - pivot : pvt                    (float, float, float) [create,query,edit]
            The pivot for scaling and rotation. Default:0.0, 0.0, 0.0
        
        - pivotX : pvx                   (float)         [create,query,edit]
            Pivot X coord.
        
        - pivotY : pvy                   (float)         [create,query,edit]
            Pivot Y coord.
        
        - pivotZ : pvz                   (float)         [create,query,edit]
            Pivot Z coord.
        
        - random : ran                   (float)         [create,query,edit]
            Random value for all parameters. Default:0.0
        
        - rotate : ro                    (float, float, float) []
        
        - rotateX : rx                   (float)         []
        
        - rotateY : ry                   (float)         []
        
        - rotateZ : rz                   (float)         []
        
        - scale : s                      (float, float, float) [create,query,edit]
            Scaling vector. Default:1.0, 1.0, 1.0
        
        - scaleX : sx                    (float)         [create,query,edit]
            Scale X coord.
        
        - scaleY : sy                    (float)         [create,query,edit]
            Scale Y coord.
        
        - scaleZ : sz                    (float)         [create,query,edit]
            Scale Z coord.
        
        - translate : t                  (float, float, float) [create,query,edit]
            Translation vector. Default:0.0, 0.0, 0.0
        
        - translateX : tx                (float)         [create,query,edit]
            Translation X coord.
        
        - translateY : ty                (float)         [create,query,edit]
            Translation Y coord.
        
        - translateZ : tz                (float)         [create,query,edit]
            Translation Z coord.
        
        - weight : w                     (float)         [create,query,edit]
            The weight, related to gravity. Default:0.0
        
        - worldSpace : ws                (bool)          [create,query,edit]
            This flag specifies which reference to use. If on: all geometrical values are
            taken in world reference. If off: all geometrical values are taken in object
            reference. C: Default is off. Q: When queried, this flag returns an int.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.polyChipOff`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class HikFloorContactMarker(Locator):
    __melnode__ = []
    
    
    __readonly__ = {}


class PositionMarker(Locator):
    __melnode__ = []
    
    
    __readonly__ = {}


class VolumeAxisField(Field):
    def detailTurbulence(self):
        """
        Returns the intensity of a second higher frequency turbulence.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.detailTurbulence`
        """
        pass
    def getDetailTurbulence(self, **kwargs):
        """
        The relative intensity of a second higher frequency turbulence. This can be used to create fine features in large scale flows. Both the speed and the frequency on this second turbulence are higher than the primary turbulence. When the detailTurbulence is non-zero the simulation may run a bit slower, due to the computation of a second turbulence.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getDirection(self):
        """
        Returns the direction attribute for the field force.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.direction`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        x-component of force direction.  Used with directional speed.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        y-component of force direction.  Used with directional speed.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        z-component of force direction.  Used with directional speed.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getDirectionalSpeed(self):
        """
        Returns the directionalSpeed attribute of the field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.directionalSpeed`
        """
        pass
    def getInvertAttenuation(self):
        """
        Returns the value of the invertAttenuation attribute for the field force.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.invertAttenuation`
        """
        pass
    def getSpeedAlongAxis(self):
        """
        Returns the alongAxis attribute of the field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.speedAlongAxis`
        """
        pass
    def getSpeedAroundAxis(self):
        """
        Returns the aroundAxis attribute of the field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.speedAroundAxis`
        """
        pass
    def getSpeedAwayFromAxis(self):
        """
        Returns the awayFromAxis attribute of the field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.speedAwayFromAxis`
        """
        pass
    def getSpeedAwayFromCenter(self):
        """
        Returns the awayFromCenter attribute of the field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.speedAwayFromCenter`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getTurbulence(self):
        """
        Returns the turbulence intensity of the field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.turbulence`
        """
        pass
    def getTurbulenceFrequency(self):
        """
        Returns the turbulenceFrequency attribute for the field force.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.turbulenceFrequency`
        """
        pass
    def getTurbulenceFrequencyX(self, **kwargs):
        """
        The repeats of the turbulence function in X.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getTurbulenceFrequencyY(self, **kwargs):
        """
        The repeats of the turbulence function in Y.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getTurbulenceFrequencyZ(self, **kwargs):
        """
        The repeats of the turbulence function in Z.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getTurbulenceOffset(self):
        """
        Returns the turbulenceOffset attribute for the field force.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.turbulenceOffset`
        """
        pass
    def getTurbulenceOffsetX(self, **kwargs):
        """
        The translation of the turbulence function in X.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getTurbulenceOffsetY(self, **kwargs):
        """
        The translation of the turbulence function in Y.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getTurbulenceOffsetZ(self, **kwargs):
        """
        The translation of the turbulence function in Z.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getTurbulenceSpeed(self):
        """
        Returns the rate of change of the turbulence over time.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.turbulenceSpeed`
        """
        pass
    def getVolumeExclusion(self, **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setDetailTurbulence(self, val='True', **kwargs):
        """
        The relative intensity of a second higher frequency turbulence. This can be used to create fine features in large scale flows. Both the speed and the frequency on this second turbulence are higher than the primary turbulence. When the detailTurbulence is non-zero the simulation may run a bit slower, due to the computation of a second turbulence.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setDirection(self, direction):
        """
        Sets the direction attribute for the field force.
        
        Parameters:
        direction : 'Vector'
            A vector representing direction.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setDirection`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        x-component of force direction.  Used with directional speed.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        y-component of force direction.  Used with directional speed.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        z-component of force direction.  Used with directional speed.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setDirectionalSpeed(self, speed):
        """
        Sets the directional speed attribute for the field force.
        
        Parameters:
        speed : 'float'
            A double representing the directional speed.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setDirectionalSpeed`
        """
        pass
    def setInvertAttenuation(self, enable):
        """
        Enables the field will be stronger the closer to the edge of the volume a point is.
        
        Parameters:
        enable : 'bool'
            Flag to invert falloff of intensity.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setInvertAttenuation`
        """
        pass
    def setSpeedAlongAxis(self, speed):
        """
        Sets the speed along axis attribute for the field force.
        
        Parameters:
        speed : 'float'
            A double representing the speed along axis.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setSpeedAlongAxis`
        """
        pass
    def setSpeedAroundAxis(self, speed):
        """
        Sets the speed around axis attribute for the field force.
        
        Parameters:
        speed : 'float'
            A double representing the speed around axis.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setSpeedAroundAxis`
        """
        pass
    def setSpeedAwayFromAxis(self, speed):
        """
        Sets the speed away from axis attribute for the field force.
        
        Parameters:
        speed : 'float'
            A double representing the speed away from axis.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setSpeedAwayFromAxis`
        """
        pass
    def setSpeedAwayFromCenter(self, speed):
        """
        Sets the speed away from center attribute for the field force.
        
        Parameters:
        speed : 'float'
            A double representing the speed away from center.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setSpeedAwayFromCenter`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setTurbulence(self, value):
        """
        Sets the turbulence attribute for the field force.
        
        Parameters:
        value : 'float'
            A double representing the turbulence intensity.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setTurbulence`
        """
        pass
    def setTurbulenceFrequency(self, value):
        """
        Sets the turbulenceFrequency attribute for the field force.
        
        Parameters:
        value : 'Vector'
            A vector representing the frequency of turbulence.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setTurbulenceFrequency`
        """
        pass
    def setTurbulenceFrequencyX(self, val='True', **kwargs):
        """
        The repeats of the turbulence function in X.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setTurbulenceFrequencyY(self, val='True', **kwargs):
        """
        The repeats of the turbulence function in Y.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setTurbulenceFrequencyZ(self, val='True', **kwargs):
        """
        The repeats of the turbulence function in Z.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setTurbulenceOffset(self, value):
        """
        Sets the turbulenceOffset attribute for the field force.
        
        Parameters:
        value : 'Vector'
            A vector representing the translation of turbulence.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setTurbulenceOffset`
        """
        pass
    def setTurbulenceOffsetX(self, val='True', **kwargs):
        """
        The translation of the turbulence function in X.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setTurbulenceOffsetY(self, val='True', **kwargs):
        """
        The translation of the turbulence function in Y.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setTurbulenceOffsetZ(self, val='True', **kwargs):
        """
        The translation of the turbulence function in Z.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setTurbulenceSpeed(self, value):
        """
        Sets the turbulence speed attribute for the field force.
        
        Parameters:
        value : 'float'
            A double representing the rate of change of the turbulence.
        
        Derived from api method `maya.OpenMayaFX.MFnVolumeAxisField.setTurbulenceSpeed`
        """
        pass
    def setVolumeExclusion(self, val='True', **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        For each listed object, the command creates a new field. The field has a shape
        which lives in the DAG and it has an associated dependency node. The field is
        added to the list of fields owned by the object. Use connectDynamic to cause the
        field to affect a dynamic object. Note that if more than one object is listed, a
        separate field is created for each object. If fields are created, this command
        returns the names of each owning shape and of the field shapes themselves. If a
        field was queried, the results of the query are returned. If a field was edited,
        the field name is returned. If no object names are provided but the active
        selection list is non-empty, the command creates a field for every object in the
        list. If the list is empty, the command defaults to -pos 0 0 0. A volume axis
        field can push particles in four directions, defined with respect to a volume:
        along the axis, away from the axis or center, around the axis, and in a user-
        specified direction.  These are analogous to the emission speed controls of
        volume emitters. The volume axis field also contains a wind turbulence model
        (different from the turbulence field) that simulates an evolving flow of liquid
        or gas. The turbulence has a build in animation that is driven by a connection
        to a time node. The transform is the associated dependency node. Use
        connectDynamic to cause the field to affect a dynamic object. If fields are
        created, this command returns the names of each of the fields. If a field was
        queried, the results of the query are returned. If a field was edited, the field
        name is returned. If object names are provided or the active selection list is
        non-empty, the command creates a field for every object in the list and calls
        addDynamic to add it to the object. If the list is empty, the command defaults
        to -pos 0 0 0. Setting the -pos flag with objects named on the command line is
        an error.
        
        Flags:
        - alongAxis : alx                (float)         [query,edit]
            Initial velocity multiplier in the direction along the central axis of the
            volume.  See the diagrams in the documentation.
        
        - aroundAxis : arx               (float)         [query,edit]
            Initial velocity multiplier in the direction around the central axis of the
            volume.  See the diagrams in the documentation.
        
        - attenuation : att              (float)         [query,edit]
            Attentuation rate of field
        
        - awayFromAxis : afx             (float)         [query,edit]
            Initial velocity multiplier in the direction away from the central axis of the
            volume.  See the diagrams in the documentation.  Used only with the cylinder,
            cone, and torus volumes.
        
        - awayFromCenter : afc           (float)         [query,edit]
            Initial velocity multiplier in the direction away from the center point of a
            cube or sphere volume. Used only with the cube and sphere volumes.
        
        - detailTurbulence : dtr         (float)         [query,edit]
            The relative intensity of a second higher frequency turbulence. This can be used
            to create fine features in large scale flows. Both the speed and the frequency
            on this second turbulence are higher than the primary turbulence. When the
            detailTurbulence is non-zero the simulation may run a bit slower, due to the
            computation of a second turbulence.
        
        - directionX : dx                (float)         [query,edit]
            x-component of force direction.  Used with directional speed.
        
        - directionY : dy                (float)         [query,edit]
            y-component of force direction.  Used with directional speed.
        
        - directionZ : dz                (float)         [query,edit]
            z-component of force direction.  Used with directional speed.
        
        - directionalSpeed : drs         (float)         [query,edit]
            Adds a component of speed in the direction specified by the directionX, Y, and Z
            attributes.
        
        - invertAttenuation : ia         (bool)          [query,edit]
            If this attribute is FALSE, the default, then the attenuation makes the field's
            effect decrease as the affected point is further from the volume's axis and
            closer to its edge.  If the is set to TRUE, then the effect of the field
            increases in this case, making the full effect of the field felt at the volume's
            edge.
        
        - magnitude : m                  (float)         [query,edit]
            Strength of field.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which field is exerted. -1 indicates that the field has no
            maximum distance.
        
        - name : n                       (unicode)       [query,edit]
            name of field
        
        - perVertex : pv                 (bool)          [query,edit]
            Per-vertex application. If this flag is set true, then each individual point
            (CV, particle, vertex,etc.) of the chosen object exerts an identical copy of the
            force field. If this flag is set to false, then the froce is exerted only from
            the geometric center of the set of points.
        
        - position : pos                 (float, float, float) [query,edit]
            Position in space (x,y,z) where you want to place a gravity field. The gravity
            then emanates from this position in space rather than from an object. Note that
            you can both use -pos (creating a field at a position) and also provide object
            names.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - turbulence : trb               (float)         [query,edit]
            Adds a force simulating a turbulent wind that evolves over time.
        
        - turbulenceFrequencyX : tfx     (float)         [query,edit]
            The repeats of the turbulence function in X.
        
        - turbulenceFrequencyY : tfy     (float)         [query,edit]
            The repeats of the turbulence function in Y.
        
        - turbulenceFrequencyZ : tfz     (float)         [query,edit]
            The repeats of the turbulence function in Z.
        
        - turbulenceOffsetX : tox        (float)         [query,edit]
            The translation of the turbulence function in X.
        
        - turbulenceOffsetY : toy        (float)         [query,edit]
            The translation of the turbulence function in Y.
        
        - turbulenceOffsetZ : toz        (float)         [query,edit]
            The translation of the turbulence function in Z.
        
        - turbulenceSpeed : trs          (float)         [query,edit]
            The rate of change of the turbulence over time. The turbulence loops seamlessly
            every 1.0/turbulenceSpeed seconds. To animate this rate attach a new time node
            to the time input on the volumeAxisNode then animate the time value on the time
            node.
        
        - volumeExclusion : vex          (bool)          [query,edit]
            Volume exclusion of the field.  If true, points outside the volume (defined by
            the volume shape attribute) are affected,  If false, points inside the volume
            are affected.  Has no effect if volumeShape is set to none.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the field.  Volume offset translates the field's volume by the
            specified amount from the actual field location. This is in the field's local
            space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the field.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.volumeAxis`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'volumeAxis'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PolyExtrudeFace(PolyMoveFace):
    __melnode__ = []
    
    
    __readonly__ = {}


class RenderBox(ImplicitBox):
    __melnode__ = []
    
    
    __readonly__ = {}


class SketchPlane(Plane):
    __melnode__ = []
    
    
    __readonly__ = {}


class THdynEmitter(PointEmitter):
    __melnode__ = []
    
    
    __readonly__ = {}


class THlocatorShape(Locator):
    __melnode__ = []
    
    
    __readonly__ = {}


class GravityField(Field):
    def getDirection(self):
        """
        Returns the direction of the gravitational force.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnGravityField.direction`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        X-component of direction.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        Y-component of direction.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        Z-component of direction                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def getVolumeExclusion(self, **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setDirection(self, gravityDirection):
        """
        Sets the direction vector of the gravitational force.
        
        Parameters:
        gravityDirection : 'Vector'
            A vector representing direction.
        
        Derived from api method `maya.OpenMayaFX.MFnGravityField.setDirection`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        X-component of direction.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        Y-component of direction.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        Z-component of direction                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setVolumeExclusion(self, val='True', **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        For each listed object, the command creates a new field. The field has a shape
        which lives in the DAG and it has an associated dependency node. The field is
        added to the list of fields owned by the object. Use connectDynamic to cause the
        field to affect a dynamic object. Note that if more than one object is listed, a
        separate field is created for each object. If fields are created, this command
        returns the names of each owning shape and of the field shapes themselves. If a
        field was queried, the results of the query are returned. If a field was edited,
        the field name is returned. If no object names are provided but the active
        selection list is non-empty, the command creates a field for every object in the
        list. If the list is empty, the command defaults to -pos 0 0 0. A gravity field
        simulates the Earth's gravitational force.   It pulls objects in a fixed
        direction (generally downward) entirely independent of their position or mass.
        The transform is the associated dependency node. Use connectDynamic to cause the
        field to affect a dynamic object. If fields are created, this command returns
        the names of each of the fields. If a field was queried, the results of the
        query are returned. If a field was edited, the field name is returned. If object
        names are provided or the active selection list is non-empty, the command
        creates a field for every object in the list and calls addDynamic to add it to
        the object. If the list is empty, the command defaults to -pos 0 0 0. Setting
        the -pos flag with objects named on the command line is an error. The default
        for -dx -dy -dz is always the opposite of the current up direction. For example,
        if the current up direction is (0,1,0) (a standard Maya configuration), then the
        gravity default is -dx 0 -dy -1 -dz 0.  The default for -a is 9.8.  9.8 meters
        per second squared happens to be standard Earth gravity, but in fact Maya
        interprets this value as centimeters per second squared.  If we were to use it
        as meters per second squared then with default Maya units, your particles would
        vanish almost in the wink of an eye. If you want a different value, set it in
        the gravity option box.
        
        Flags:
        - attenuation : att              (float)         [query,edit]
            Attentuation rate of field
        
        - directionX : dx                (float)         [query,edit]
            X-component of direction.
        
        - directionY : dy                (float)         [query,edit]
            Y-component of direction.
        
        - directionZ : dz                (float)         [query,edit]
            Z-component of direction
        
        - magnitude : m                  (float)         [query,edit]
            Strength of field.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which field is exerted. -1 indicates that the field has no
            maximum distance.
        
        - name : n                       (unicode)       [query,edit]
            name of field
        
        - perVertex : pv                 (bool)          [query,edit]
            Per-vertex application. If this flag is set true, then each individual point
            (CV, particle, vertex,etc.) of the chosen object exerts an identical copy of the
            force field. If this flag is set to false, then the froce is exerted only from
            the geometric center of the set of points.
        
        - position : pos                 (float, float, float) [query,edit]
            Position in space (x,y,z) where you want to place a gravity field. The gravity
            then emanates from this position in space rather than from an object. Note that
            you can both use -pos (creating a field at a position) and also provide object
            names.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - volumeExclusion : vex          (bool)          [query,edit]
            Volume exclusion of the field.  If true, points outside the volume (defined by
            the volume shape attribute) are affected,  If false, points inside the volume
            are affected.  Has no effect if volumeShape is set to none.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the field.  Volume offset translates the field's volume by the
            specified amount from the actual field location. This is in the field's local
            space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the field.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.gravity`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'gravity'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AbsUniqueOverride(AbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FluidEmitter(PointEmitter):
    def fluidVoxelInfo(*args, **kwargs):
        """
        Provides basic information about the mapping of a fluid voxel grid into world-
        or object space of the fluid.  Use this command to determine the center point of
        a voxel, or to find the voxel containing a given point, among other things.
        
        Flags:
        - checkBounds : cb               (bool)          [create]
            If this flag is on, and the voxel index of a point that is out of bounds is
            requested, then we return nothing.
        
        - inBounds : ib                  (int, int, int) [create]
            Are the three ints representing the x, y, z indices of a voxel within the bounds
            of the fluid's voxel grid?  True if yes, false if not.  (For 2D fluids, pass in
            z=0 for the third argument.  See examples.)
        
        - objectSpace : os               (bool)          [create]
            Whether the queried value should be returned in object space (TRUE), or world
            space (FALSE, the default).
        
        - radius : r                     (float)         [create]
            Modifier for the -voxel flag.  Returns a list of index triples identifying
            voxels that fall within the given radius of the point specified by the -voxel
            flag.
        
        - voxel : v                      (float, float, float) [create]
            Returns array of three ints representing the x, y, z indices of the voxel within
            which the given point position is contained. If the checkBounds flag is on, and
            the point is out of bounds, we return nothing. Otherwise, even if the point is
            out of bounds, index values are returned. When combined with the -radius flag,
            returns an array of index triples representing a list of voxels within a given
            radius of the given point position.
        
        - voxelCenter : vc               (bool)          [create]
            The center position of the specified voxels.  Returns an array of floats (three
            for each of the indices in the query).  (Valid only with the -xIndex, -yIndex,
            and -zIndex flags.)
        
        - xIndex : xi                    (int)           [create]
            Only return values for cells with this X index
        
        - yIndex : yi                    (int)           [create]
            Only return values for cells with this Y index
        
        - zIndex : zi                    (int)           [create]
            Only return values for cells with this Z index                             Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.fluidVoxelInfo`
        """
        pass
    def getCycleEmission(self, **kwargs):
        """
        Possible values are noneand frame.Cycling emission restarts the random number stream after a specified interval.  This can either be a number of frames or a number of emitted particles.  In each case the number is specified by the cycleInterval attribute. Setting cycleEmission to frameand cycleInterval to 1 will then re-start the random stream every frame. Setting cycleInterval to values greater than 1 can be used to generate cycles for games work.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getCycleInterval(self, **kwargs):
        """
        Specifies the number of frames or particles between restarts of the random number stream.  See cycleEmission.  Has no effect if cycleEmission is set to None.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getDensityEmissionRate(self, **kwargs):
        """
        Rate at which density is emitted.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getFluidAttr(*args, **kwargs):
        """
        Returns values of built-in fluid attributes such as density, velocity, etc., for
        individual grid cells or for all cells in the grid.
        
        Flags:
        - attribute : at                 (unicode)       [create]
            Specifies the fluid attribute for which to display values.  Valid attributes are
            force, velocity, density, falloff, fuel, color, and temperature.  (Note that
            getting force values is an alternate way of getting velocity values at one time
            step.)
        
        - lowerFace : lf                 (bool)          [create]
            Only valid with -at velocity.  Since velocity values are stored on the edges of
            each voxel and not at the center, using voxel based indices to set velocity
            necessarily affects neighboring voxels.  Use this flag to only set velocity
            components on the lower left three faces of a voxel, rather than all six.
        
        - xIndex : xi                    (int)           [create]
            Only return values for cells with this X index
        
        - xvalue : x                     (bool)          []
            Only get the first component of the vector-valued attribute specified by the
            -at/attributeflag.
        
        - yIndex : yi                    (int)           [create]
            Only return values for cells with this Y index
        
        - yvalue : y                     (bool)          []
            Only get the second component of the vector-valued attribute specified by the
            -at/attributeflag.
        
        - zIndex : zi                    (int)           [create]
            Only return values for cells with this Z index
        
        - zvalue : z                     (bool)          []
            Only get the third component of the vector-valued attribute specified by the
            -at/attributeflag.                                    Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.getFluidAttr`
        """
        pass
    def getFluidDropoff(self, **kwargs):
        """
        Fluid Emission Dropoff in volume                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getFuelEmissionRate(self, **kwargs):
        """
        Rate at which  is emitted.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getHeatEmissionRate(self, **kwargs):
        """
        Rate at which density is emitted.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getMaxDistance(self, **kwargs):
        """
        Maximum distance at which emission ends.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getMinDistance(self, **kwargs):
        """
        Minimum distance at which emission starts.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getPosition(self, **kwargs):
        """
        world-space position                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getRate(self, **kwargs):
        """
        Rate at which particles emitted (can be non-integer). For point emission this is rate per point per unit time. For surface emission it is rate per square unit of area per unit time.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getType(self, **kwargs):
        """
        Type of emitter. The choices are omni | dir | direction | surf | surface | curve | curv. The default is omni. The full definition of these types are: omnidirectional point emitter, directional point emitter, surface emitter, or curve emitter.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the emitter.  Volume offset translates the emission volume by the specified amount from the actual emitter location.  This is in the emitter's local space.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the emitter.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which particles are generated. Values are: cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the emitter.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def loadFluid(*args, **kwargs):
        """
        A command to set builtin fluid attributes such as Density, Velocity, etc for all
        cells in the grid from the initial state cache                  In query mode,
        return type is based on queried flag.
        
        Flags:
        - currentTime : ct               (bool)          [create,query,edit]
            This flag is now obsolete. Move the cache clip in the Trax editor to view
            different frames of the playback cache.
        
        - frame : f                      (float)         [create,query,edit]
            This flag is now obsolete. Move the cache clip in the Trax editor to view
            different frames of the playback cache.
        
        - initialConditions : ic         (bool)          [create,query,edit]
            load initial conditions cache                              Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.loadFluid`
        """
        pass
    def resampleFluid(*args, **kwargs):
        """
        A command to extend the fluid grid, keeping the voxels the same size, and
        keeping the existing contents of the fluid in the same place. Note that the
        fluid transform is also modified to make this possible.            In query
        mode, return type is based on queried flag.
        
        Flags:
        - resampleDepth : rd             (int)           [create,query,edit]
            Change depth resolution to this value
        
        - resampleHeight : rh            (int)           [create,query,edit]
            Change height resolution to this value
        
        - resampleWidth : rw             (int)           [create,query,edit]
            Change width resolution to this value                              Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.resampleFluid`
        """
        pass
    def saveFluid(*args, **kwargs):
        """
        A command to save the current state of the fluid to the initial state cache. The
        grids to be saved are determined by the cache attributes: cacheDensity,
        cacheVelocity, etc. These attributes are normally set from the options on Set
        Initial State. The cache must be set up before invoking this command.
        In query mode, return type is based on queried flag.
        
        Flags:
        - currentTime : ct               (int)           [create,query,edit]
            cache state of fluid at current time
        
        - endTime : et                   (int)           [create,query,edit]
            end Time for cacheing
        
        - startTime : st                 (int)           [create,query,edit]
            start Time for cacheing                                    Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.saveFluid`
        """
        pass
    def setCycleEmission(self, val='True', **kwargs):
        """
        Possible values are noneand frame.Cycling emission restarts the random number stream after a specified interval.  This can either be a number of frames or a number of emitted particles.  In each case the number is specified by the cycleInterval attribute. Setting cycleEmission to frameand cycleInterval to 1 will then re-start the random stream every frame. Setting cycleInterval to values greater than 1 can be used to generate cycles for games work.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setCycleInterval(self, val='True', **kwargs):
        """
        Specifies the number of frames or particles between restarts of the random number stream.  See cycleEmission.  Has no effect if cycleEmission is set to None.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setDensityEmissionRate(self, val='True', **kwargs):
        """
        Rate at which density is emitted.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setFluidAttr(*args, **kwargs):
        """
        Sets values of built-in fluid attributes such as density, velocity, etc., for
        individual grid cells or for all cells in the grid.
        
        Flags:
        - addValue : ad                  (bool)          []
            Add specified value to attribute
        
        - attribute : at                 (unicode)       [create]
            Specifies the fluid attribute for which to set values.  Valid attributes are
            velocity, density, fuel, color, falloff, and temperature.
        
        - clear : cl                     (bool)          []
            Set this attribute to 0
        
        - floatRandom : fr               (float)         []
            If this was a scalar (e.g. density) attribute, use a random value in +-VALUE If
            fv is specified, it is used as the base value and combined with the random
            value. If the fv flag is not specified, the  base is assumed to be 0.
        
        - floatValue : fv                (float)         []
            If this was a scalar (e.g. density) attribute, use this value
        
        - lowerFace : lf                 (bool)          [create]
            Only valid with -at velocity.  Since velocity values are stored on the edges of
            each voxel and not at the center, using voxel based indices to set velocity
            necessarily affects neighboring voxels.  Use this flag to only set velocity
            components on the lower left three faces of a voxel, rather than all six.
        
        - reset : re                     (bool)          []
            Set this attribute to default value
        
        - vectorRandom : vr              (float, float, float) []
            If this was a vector (e.g. velocity) attribute, use a random value in +-VALUE If
            vv is specified, it is used as the base value and combined with the random
            value. If the vv flag is not specified, the  base is assumed to be 0,0,0.
        
        - vectorValue : vv               (float, float, float) []
            If this was a vector (e.g. velocity) attribute, use this value
        
        - xIndex : xi                    (int)           [create]
            Only return values for cells with this X index
        
        - xvalue : x                     (bool)          []
            Only set the first component of the vector-valued attribute specified by the
            -at/attributeflag.
        
        - yIndex : yi                    (int)           [create]
            Only return values for cells with this Y index
        
        - yvalue : y                     (bool)          []
            Only set the second component of the vector-valued attribute specified by the
            -at/attributeflag.
        
        - zIndex : zi                    (int)           [create]
            Only return values for cells with this Z index
        
        - zvalue : z                     (bool)          []
            Only set the third component of the vector-valued attribute specified by the
            -at/attributeflag.                                    Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.setFluidAttr`
        """
        pass
    def setFluidDropoff(self, val='True', **kwargs):
        """
        Fluid Emission Dropoff in volume                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setFuelEmissionRate(self, val='True', **kwargs):
        """
        Rate at which  is emitted.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setHeatEmissionRate(self, val='True', **kwargs):
        """
        Rate at which density is emitted.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setMaxDistance(self, val='True', **kwargs):
        """
        Maximum distance at which emission ends.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setMinDistance(self, val='True', **kwargs):
        """
        Minimum distance at which emission starts.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setPosition(self, val='True', **kwargs):
        """
        world-space position                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setRate(self, val='True', **kwargs):
        """
        Rate at which particles emitted (can be non-integer). For point emission this is rate per point per unit time. For surface emission it is rate per square unit of area per unit time.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setType(self, val='True', **kwargs):
        """
        Type of emitter. The choices are omni | dir | direction | surf | surface | curve | curv. The default is omni. The full definition of these types are: omnidirectional point emitter, directional point emitter, surface emitter, or curve emitter.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the emitter.  Volume offset translates the emission volume by the specified amount from the actual emitter location.  This is in the emitter's local space.                  
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the emitter.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which particles are generated. Values are: cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the emitter.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Creates, edits or queries an auxiliary dynamics object (for example, a field or
        emitter). Creates an emitter object. If object names are provided or if objects
        are selected, applies the emitter to the named/selected object(s)in the scene.
        Fluid will then be emitted from each. If no objects are named or selected, or if
        the -pos option is specified, creates a positional emitter. If an emitter was
        created, the command returns the name of the object owning the emitter, and the
        name of emitter shape. If an emitter was queried, the command returns the
        results of the query.
        
        Flags:
        - cycleEmission : cye            (unicode)       [query,edit]
            Possible values are noneand frame.Cycling emission restarts the random number
            stream after a specified interval.  This can either be a number of frames or a
            number of emitted particles.  In each case the number is specified by the
            cycleInterval attribute. Setting cycleEmission to frameand cycleInterval to 1
            will then re-start the random stream every frame. Setting cycleInterval to
            values greater than 1 can be used to generate cycles for games work.
        
        - cycleInterval : cyi            (int)           [query,edit]
            Specifies the number of frames or particles between restarts of the random
            number stream.  See cycleEmission.  Has no effect if cycleEmission is set to
            None.
        
        - densityEmissionRate : der      (float)         [query,edit]
            Rate at which density is emitted.
        
        - fluidDropoff : fdr             (float)         [query,edit]
            Fluid Emission Dropoff in volume
        
        - fuelEmissionRate : fer         (float)         [query,edit]
            Rate at which  is emitted.
        
        - heatEmissionRate : her         (float)         [query,edit]
            Rate at which density is emitted.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which emission ends.
        
        - minDistance : mnd              (float)         [query,edit]
            Minimum distance at which emission starts.
        
        - name : n                       (unicode)       [create,query,edit]
            Object name
        
        - position : pos                 (float, float, float) [create,query,edit]
            world-space position
        
        - rate : r                       (float)         [query,edit]
            Rate at which particles emitted (can be non-integer). For point emission this is
            rate per point per unit time. For surface emission it is rate per square unit of
            area per unit time.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - type : typ                     (unicode)       [query,edit]
            Type of emitter. The choices are omni | dir | direction | surf | surface | curve
            | curv. The default is omni. The full definition of these types are:
            omnidirectional point emitter, directional point emitter, surface emitter, or
            curve emitter.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the emitter.  Volume offset translates the emission volume by
            the specified amount from the actual emitter location.  This is in the emitter's
            local space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the emitter.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which particles are generated. Values are: cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the emitter.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.fluidEmitter`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RelUniqueOverride(RelOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ArcLengthDimension(NurbsDimShape):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create an arcLength dimension to display the arcLength
        of a curve/surface at a specified point on the curve/surface.
        
        
        Derived from mel command `maya.cmds.arcLengthDimension`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ConnectionOverride(AbsOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class RadialField(Field):
    def getRadialType(self):
        """
        Returns a type that controls the way the radial field is attenuated.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnRadialField.radialType`
        """
        pass
    def setRadialType(self, value):
        """
        Sets a radial field type that controls the way the field is attenuated.
        
        Parameters:
        value : 'float'
            A value representing a type of radial field attenuation. A value of 1 uses the magnitude, attenuation, and distance settings from the field to determine the net force of the radial field. A value of 0 will use the ratio of the absolute distance and the maximum distance setting. A value between 0 and 1 will create a linear blend between the two types.
        
        Derived from api method `maya.OpenMayaFX.MFnRadialField.setType`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ParamDimension(NurbsDimShape):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is used to create a param dimension to display the parameter value
        of a curve/surface at a specified point on the curve/surface.
        
        
        Derived from mel command `maya.cmds.paramDimension`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NonAmbientLightShapeNode(RenderLight):
    def getDecayRate(self):
        """
        Retrieves the value of the "decayRate" attribute of a non-ambient light node. This attribute determines the type of decay for the light.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNonAmbientLight.decayRate`
        """
        pass
    def setDecayRate(self, decay_rate):
        """
        Sets the value of the "decayRate" attribute of a non-ambient light node.
        
        Parameters:
        decay_rate : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonAmbientLight.setDecayRate`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DropoffLocator(Locator):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command adds one or more dropoff locators to a wire curve, one for each
        selected curve point. The dropoff locators can be used to provide localized
        tuning of the wire deformation about the curve point. The arguments are two
        floats, the envelope and percentage, followed by the wire node name and then by
        the curve point(s).
        
        
        Derived from mel command `maya.cmds.dropoffLocator`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class TurbulenceField(Field):
    def getFrequency(self):
        """
        Returns the frequency parameter that generates irregularities in the fields motion.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnTurbulenceField.frequency`
        """
        pass
    def getNoiseLevel(self, **kwargs):
        """
        If the noiseLevel parameter is greater than zero, the field will do multiple lookups in the table.  Each additional lookup is weighted using noiseRatio (which see).  The noiseLevel is the number of additional lookups, so if noiseLevel is 0, there is just one lookup.  A value of 0 (the default) corresponds to the way the field behaved prior to Maya 3.0.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getNoiseRatio(self, **kwargs):
        """
        If noiseLevel is greater than zero, then noiseRatio is the relative magnitude for each consecutive noise evaluation. These are cumulative: for example, if noiseRatio is 0.5, then the first evaluation is weighted 0.5, the second 0.25, and so on. Has no effect if noiseLevel is zero.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getPhase(self):
        """
        Returns the phase shift parameter that influences the direction of the turbulence field disruption. Currently this returns the phaseZ attribute, which was called simply phase in versions of Maya prior to 3.0.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnTurbulenceField.phase`
        """
        pass
    def getPhaseX(self, **kwargs):
        """
        X component of phase shift of turbulence field. This influences the direction of the disruption.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getPhaseY(self, **kwargs):
        """
        Y component of phase shift of turbulence field. This influences the direction of the disruption.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getPhaseZ(self, **kwargs):
        """
        Z component of phase shift of turbulence field. This influences the direction of the disruption.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getVolumeExclusion(self, **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setFrequency(self, value):
        """
        Sets the frequency parameter of the Perlin noise function used by the turbulence field. Values are positive, with larger values causing more frequent irregularities in the motion.
        
        Parameters:
        value : 'float'
            A value representing a noise generation parameter.
        
        Derived from api method `maya.OpenMayaFX.MFnTurbulenceField.setFrequency`
        """
        pass
    def setNoiseLevel(self, val='True', **kwargs):
        """
        If the noiseLevel parameter is greater than zero, the field will do multiple lookups in the table.  Each additional lookup is weighted using noiseRatio (which see).  The noiseLevel is the number of additional lookups, so if noiseLevel is 0, there is just one lookup.  A value of 0 (the default) corresponds to the way the field behaved prior to Maya 3.0.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setNoiseRatio(self, val='True', **kwargs):
        """
        If noiseLevel is greater than zero, then noiseRatio is the relative magnitude for each consecutive noise evaluation. These are cumulative: for example, if noiseRatio is 0.5, then the first evaluation is weighted 0.5, the second 0.25, and so on. Has no effect if noiseLevel is zero.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setPhase(self, value):
        """
        Sets the phase shift parameter of the Perlin noise function used by the turbulence field. Both positive and negative values are legal and influence the direction of the disruption. Sets the phaseZ parameter, which was called simply phase in versions of Maya prior to 3.0.
        
        Parameters:
        value : 'float'
            A value representing a noise generation parameter.
        
        Derived from api method `maya.OpenMayaFX.MFnTurbulenceField.setPhase`
        """
        pass
    def setPhaseX(self, val='True', **kwargs):
        """
        X component of phase shift of turbulence field. This influences the direction of the disruption.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setPhaseY(self, val='True', **kwargs):
        """
        Y component of phase shift of turbulence field. This influences the direction of the disruption.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setPhaseZ(self, val='True', **kwargs):
        """
        Z component of phase shift of turbulence field. This influences the direction of the disruption.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setVolumeExclusion(self, val='True', **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        For each listed object, the command creates a new field. The field has a shape
        which lives in the DAG and it has an associated dependency node. The field is
        added to the list of fields owned by the object. Use connectDynamic to cause the
        field to affect a dynamic object. Note that if more than one object is listed, a
        separate field is created for each object. If fields are created, this command
        returns the names of each owning shape and of the field shapes themselves. If a
        field was queried, the results of the query are returned. If a field was edited,
        the field name is returned. If no object names are provided but the active
        selection list is non-empty, the command creates a field for every object in the
        list. If the list is empty, the command defaults to -pos 0 0 0. A turbulence
        field causes irregularities (also called 'noise' or 'jitter') in the motion of
        affected objects. Use connectDynamic to cause the field to affect a dynamic
        object. If fields are created, this command returns the names of each of the
        fields. If a field was queried, the results of the query are returned. If a
        field was edited, the field name is returned. If object names are provided or
        the active selection list is non-empty, the command creates a field for every
        object in the list and calls addDynamic to add it to the object. If the list is
        empty, the command defaults to -pos 0 0 0. Setting the -pos flag with objects
        named on the command line is an error.
        
        Flags:
        - attenuation : att              (float)         [query,edit]
            Attentuation rate of field
        
        - frequency : f                  (float)         [query,edit]
            Frequency of turbulence field. This determines how often motion is disrupted.
        
        - magnitude : m                  (float)         [query,edit]
            Strength of field.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which field is exerted. -1 indicates that the field has no
            maximum distance.
        
        - name : n                       (unicode)       [query,edit]
            name of field
        
        - noiseLevel : nsl               (int)           [query,edit]
            If the noiseLevel parameter is greater than zero, the field will do multiple
            lookups in the table.  Each additional lookup is weighted using noiseRatio
            (which see).  The noiseLevel is the number of additional lookups, so if
            noiseLevel is 0, there is just one lookup.  A value of 0 (the default)
            corresponds to the way the field behaved prior to Maya 3.0.
        
        - noiseRatio : nsr               (float)         [query,edit]
            If noiseLevel is greater than zero, then noiseRatio is the relative magnitude
            for each consecutive noise evaluation. These are cumulative: for example, if
            noiseRatio is 0.5, then the first evaluation is weighted 0.5, the second 0.25,
            and so on. Has no effect if noiseLevel is zero.
        
        - perVertex : pv                 (bool)          [query,edit]
            Per-vertex application. If this flag is set true, then each individual point
            (CV, particle, vertex,etc.) of the chosen object exerts an identical copy of the
            force field. If this flag is set to false, then the froce is exerted only from
            the geometric center of the set of points.
        
        - phase : p                      (float)         [query,edit]
            Phase shift of turbulence field. This influences the direction of the
            disruption.  This flag is obsolete and is retained only for backward
            compatibility.  It is replaced by -phaseX, -phaseY, and -phaseZ.  Setting -phase
            is identical to setting -phaseZ (the phase shift was always in the Z dimension).
        
        - phaseX : px                    (float)         [query,edit]
            X component of phase shift of turbulence field. This influences the direction of
            the disruption.
        
        - phaseY : py                    (float)         [query,edit]
            Y component of phase shift of turbulence field. This influences the direction of
            the disruption.
        
        - phaseZ : pz                    (float)         [query,edit]
            Z component of phase shift of turbulence field. This influences the direction of
            the disruption.
        
        - position : pos                 (float, float, float) [query,edit]
            Position in space (x,y,z) where you want to place a gravity field. The gravity
            then emanates from this position in space rather than from an object. Note that
            you can both use -pos (creating a field at a position) and also provide object
            names.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - volumeExclusion : vex          (bool)          [query,edit]
            Volume exclusion of the field.  If true, points outside the volume (defined by
            the volume shape attribute) are affected,  If false, points inside the volume
            are affected.  Has no effect if volumeShape is set to none.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the field.  Volume offset translates the field's volume by the
            specified amount from the actual field location. This is in the field's local
            space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the field.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.turbulence`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'turbulence'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AirField(Field):
    def fanSetup(self, val='True', **kwargs):
        """
        Similar to 'windSetup' except that the effects of a fan or a person blowing air are approximated. The user can pass the same flags on the command line to adjust them from the defaults. These are the values that get set to approximate a 'fan': inheritVelocity 1.0 inheritRotation true componentOnly false enableSpread true spread .5 (45 degrees from center )                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getComponentOnly(self):
        """
        Returns true if the air field will apply force only in the direction specified by the combination of its direction, speed, and inherit velocity attributes. Returns false if the force is made to effect the object's velocity to match the air field's velocity.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.componentOnly`
        """
        pass
    def getDirection(self):
        """
        Returns the direction the air is blowing.
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.direction`
        """
        pass
    def getDirectionX(self, **kwargs):
        """
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getDirectionY(self, **kwargs):
        """
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getDirectionZ(self, **kwargs):
        """
        Direction that the air will try to match the affected particles' velocity to. NOTE: This is not the velocity; this is only the direction. Use the -s flag to set the speed.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getEnableSpread(self):
        """
        Returns true if the air field is using the spread angle to define the influence of the air field.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.enableSpread`
        """
        pass
    def getInheritRotation(self):
        """
        Returns true if the air field is rotating or parented to a rotating object, and will undergo that same rotation.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.inheritRotation`
        """
        pass
    def getInheritVelocity(self):
        """
        Returns the amount of the moving air field's velocity that is added to the direction and magnitude of the wind.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.inheritVelocity`
        """
        pass
    def getPosition(self, **kwargs):
        """
        Position in space (x,y,z) where you want to place a gravity field. The gravity then emanates from this position in space rather than from an object. Note that you can both use -pos (creating a field at a position) and also provide object names.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getSpeed(self):
        """
        Returns the control setting on how quickly objects match the velocity of the air field.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.speed`
        """
        pass
    def getSpread(self):
        """
        Returns a value that represents an angle which objects are affected by the air fields direction setting. This value is taken into account when the Enable Spread attribute is turned on.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.spread`
        """
        pass
    def getTorusSectionRadius(self, **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getVelocityComponentOnly(self, **kwargs):
        """
        If this is 'false', the air will accelerate or decelerate the affected objects so that their velocities will eventually match the TOTAL velocity vector of the air field. If this is 'true', only ACCELERTION is applied to the affected objects so that their velocity component along the TOTAL velocity vector matches or is greater in magnitude than the TOTAL velocity vector. This will not slow objects down to match velocities, only speed them up to match components. This is most useful when using the -iv flag with a value 0.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getVolumeExclusion(self, **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getVolumeOffset(self, **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getVolumeShape(self, **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def getVolumeSweep(self, **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setComponentOnly(self, enable):
        """
        Enables the air field to apply force specified as a combination of its direction, speed, and inherit veloicty attributes.
        
        Parameters:
        enable : 'bool'
            Flag to enable or disable combination of attributes.
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.setComponentOnly`
        """
        pass
    def setDirection(self, airDirection):
        """
        Sets the direction vector for the air to blow.
        
        Parameters:
        airDirection : 'Vector'
            A vector representing direction.
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.setDirection`
        """
        pass
    def setDirectionX(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setDirectionY(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setDirectionZ(self, val='True', **kwargs):
        """
        Direction that the air will try to match the affected particles' velocity to. NOTE: This is not the velocity; this is only the direction. Use the -s flag to set the speed.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setEnableSpread(self, enable):
        """
        Enables the air field to influence objects based on the spread angle setting.
        
        Parameters:
        enable : 'bool'
            Flag to enable or disable use of the spread angle.
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.setEnableSpread`
        """
        pass
    def setInheritRotation(self, enable):
        """
        Enables the air field to undergo rotations and effect the direction that the air field points.
        
        Parameters:
        enable : 'bool'
            Flag to enable or disable rotations effects.
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.setInheritRotation`
        """
        pass
    def setInheritVelocity(self, velocity):
        """
        Sets the amount of the moving air field's velocity that is added to the direction and magnitude of the wind.
        
        Parameters:
        velocity : 'float'
            A value from 0 to 1 representing the amount of velocity that is added.
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.setInheritVelocity`
        """
        pass
    def setPosition(self, val='True', **kwargs):
        """
        Position in space (x,y,z) where you want to place a gravity field. The gravity then emanates from this position in space rather than from an object. Note that you can both use -pos (creating a field at a position) and also provide object names.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setSpeed(self, value):
        """
        Sets the control setting on how quickly the objects match the velocity of the air field.
        
        Parameters:
        value : 'float'
            A value representing speed. A value of 0 is equivalent of turning the air field off. A value of 1 and objects will match the velocity almost instantaneously.
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.setSpeed`
        """
        pass
    def setSpread(self, value):
        """
        Sets the value representing an angle which objects are affected by the air fields direction setting. This value is taken into account when the Enable Spread attribute is turned on.
        
        Parameters:
        value : 'float'
            A value representing an angle. A value of 0 effects objects only exactly in front of the direction vector. A value of 1 effects objects in front by 180 degrees along the direction vector.
        
        Derived from api method `maya.OpenMayaFX.MFnAirField.setSpread`
        """
        pass
    def setTorusSectionRadius(self, val='True', **kwargs):
        """
        Section radius for a torus volume.  Applies only to torus. Similar to the section radius in the torus modelling primitive.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setVelocityComponentOnly(self, val='True', **kwargs):
        """
        If this is 'false', the air will accelerate or decelerate the affected objects so that their velocities will eventually match the TOTAL velocity vector of the air field. If this is 'true', only ACCELERTION is applied to the affected objects so that their velocity component along the TOTAL velocity vector matches or is greater in magnitude than the TOTAL velocity vector. This will not slow objects down to match velocities, only speed them up to match components. This is most useful when using the -iv flag with a value 0.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setVolumeExclusion(self, val='True', **kwargs):
        """
        Volume exclusion of the field.  If true, points outside the volume (defined by the volume shape attribute) are affected,  If false, points inside the volume are affected.  Has no effect if volumeShape is set to none.
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setVolumeOffset(self, val='True', **kwargs):
        """
        Volume offset of the field.  Volume offset translates the field's volume by the specified amount from the actual field location. This is in the field's local space.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setVolumeShape(self, val='True', **kwargs):
        """
        Volume shape of the field.  Sets/edits/queries the field's volume shape attribute.  If set to any value other than none, determines a 3-D volume within which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def setVolumeSweep(self, val='True', **kwargs):
        """
        Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.  Similar effect to the sweep attribute in modelling.                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def wakeSetup(self, val='True', **kwargs):
        """
        Like the 'windSetup' and 'fanSetup', 'wakeSetup' sets certain values in the field to approximate the movement of air near a moving object, such as  a character's foot or hand. The values that are set are: inheritVelocity 1.0 inheritRotation false componentOnly true enableSpread false speed 0.0                  
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    def windSetup(self, val='True', **kwargs):
        """
        This will set some of the values above in a way that approximates the effects of a basic wind. This allows the user to then change certain values as he/she wishes on the same command line. First the preset values get set, and then any other flags that were passed get taken into account. These are the values that get set to approximate 'wind': inheritVelocity 0.0 inheritRotation true componentOnly false enableSpread false                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        For each listed object, the command creates a new field. The field has a shape
        which lives in the DAG and it has an associated dependency node. The field is
        added to the list of fields owned by the object. Use connectDynamic to cause the
        field to affect a dynamic object. Note that if more than one object is listed, a
        separate field is created for each object. If fields are created, this command
        returns the names of each owning shape and of the field shapes themselves. If a
        field was queried, the results of the query are returned. If a field was edited,
        the field name is returned. If no object names are provided but the active
        selection list is non-empty, the command creates a field for every object in the
        list. If the list is empty, the command defaults to -pos 0 0 0. The air field
        simulates the effects of moving air. The affected objects will be accelerated or
        decelerated so that their velocities match that of the air. With the '-vco true'
        flag thrown, only accelerations are applied. By parenting an air field to a
        moving part of an object (ie. a foot of a character) and using '-i 1 -m 0 -s .5
        -vco true' flags, one can simulate the movement of air around the foot as it
        moves, since the TOTAL velocity vector of the field would be only based on the
        movement of the foot. This can be done while the character walks through leaves
        or dust on the ground. For each listed object, the command creates a new field.
        The transform is the associated dependency node. Use connectDynamic to cause the
        field to affect a dynamic object. If fields are created,  this command returns
        the field names. If a field was queried, the results of the query are returned.
        If a field was edited, the field name is returned. If the -pos flag is
        specified, a field is created at the position specified. If not, if object names
        are provided or the active selection list is non-empty, the command creates a
        field for every object in the list and calls addDynamic to add it to the object;
        otherwise the command defaults to -pos 0 0 0. Setting the -pos flag with objects
        named on the command line is an error.
        
        Flags:
        - attenuation : att              (float)         [query,edit]
            Attentuation rate of field
        
        - directionX : dx                (float)         [query,edit]
        
        - directionY : dy                (float)         [query,edit]
        
        - directionZ : dz                (float)         [query,edit]
            Direction that the air will try to match the affected particles' velocity to.
            NOTE: This is not the velocity; this is only the direction. Use the -s flag to
            set the speed.
        
        - enableSpread : es              (bool)          [query,edit]
            This tells the system whether or not to use the spread angle given by '-sp'. If
            this is 'false' then all connected objectswithin the maximum distance will be
            affected. Also, if this is set to 'false', all affected objects are forced to
            match their velocities along the direction vector. If this is set to 'true' and
            spread is used, then the direction of the force is along the direction from the
            field to the object.
        
        - fanSetup : fs                  (bool)          [edit]
            Similar to 'windSetup' except that the effects of a fan or a person blowing air
            are approximated. The user can pass the same flags on the command line to adjust
            them from the defaults. These are the values that get set to approximate a
            'fan': inheritVelocity 1.0 inheritRotation true componentOnly false enableSpread
            true spread .5 (45 degrees from center )
        
        - inheritRotation : iro          (bool)          [query,edit]
            If this is set to 'true', then the direction vector described with -dx, -dy, and
            -dz will be considered local to the owning object. Therefore, if the owning
            object's transform undergoes any rotation (by itself or one of its parents), the
            direction vector of the air field will undergo that same rotation.
        
        - inheritVelocity : iv           (float)         [query,edit]
            Amount (from 0 to 1) of the field-owner's velocity added to the vector
            determined by the direction and speed flags. The combination of these two
            vectors makes up the TOTAL velocity vector for the air field. This allows the
            air to be determined directly by the motion of the owning object.
        
        - magnitude : m                  (float)         [query,edit]
            Strength of field.
        
        - maxDistance : mxd              (float)         [query,edit]
            Maximum distance at which field is exerted. -1 indicates that the field has no
            maximum distance.
        
        - name : n                       (unicode)       [query,edit]
            name of field
        
        - perVertex : pv                 (bool)          [query,edit]
            Per-vertex application. If this flag is set true, then each individual point
            (CV, particle, vertex,etc.) of the chosen object exerts an identical copy of the
            force field. If this flag is set to false, then the froce is exerted only from
            the geometric center of the set of points.
        
        - position : pos                 (float, float, float) [query,edit]
            Position in space (x,y,z) where you want to place a gravity field. The gravity
            then emanates from this position in space rather than from an object. Note that
            you can both use -pos (creating a field at a position) and also provide object
            names.
        
        - speed : s                      (float)         [query,edit]
            How fast the affected objects' speed reaches the speed (based on the -mag, -dx,
            -dy, -dz flags) of the air field. This value gets clamped internally to be
            between 0.0 and 1.0.  A value of 0.0 will make the air field have no effect. A
            value of 1.0 will try to match the air field's speed much quicker, but not
            necessarily immediately.
        
        - spread : sp                    (float)         [query,edit]
            This represents the angle from the direction vector within which objects will be
            affected. The values are in the range of 0 to 1. A value of 0 will result in an
            effect only exactly in front of the air field along the direction vector. A
            value of 1 will result in any object in front of the owning object, 90 degrees
            in all direction from the direction vector.
        
        - torusSectionRadius : tsr       (float)         [query,edit]
            Section radius for a torus volume.  Applies only to torus. Similar to the
            section radius in the torus modelling primitive.
        
        - velocityComponentOnly : vco    (bool)          [query,edit]
            If this is 'false', the air will accelerate or decelerate the affected objects
            so that their velocities will eventually match the TOTAL velocity vector of the
            air field. If this is 'true', only ACCELERTION is applied to the affected
            objects so that their velocity component along the TOTAL velocity vector matches
            or is greater in magnitude than the TOTAL velocity vector. This will not slow
            objects down to match velocities, only speed them up to match components. This
            is most useful when using the -iv flag with a value 0.
        
        - volumeExclusion : vex          (bool)          [query,edit]
            Volume exclusion of the field.  If true, points outside the volume (defined by
            the volume shape attribute) are affected,  If false, points inside the volume
            are affected.  Has no effect if volumeShape is set to none.
        
        - volumeOffset : vof             (float, float, float) [query,edit]
            Volume offset of the field.  Volume offset translates the field's volume by the
            specified amount from the actual field location. This is in the field's local
            space.
        
        - volumeShape : vsh              (unicode)       [query,edit]
            Volume shape of the field.  Sets/edits/queries the field's volume shape
            attribute.  If set to any value other than none, determines a 3-D volume within
            which the field has effect. Values are: none,cube,sphere,cylinder,cone,torus.
        
        - volumeSweep : vsw              (float)         [query,edit]
            Volume sweep of the field.  Applies only to sphere, cone, cylinder, and torus.
            Similar effect to the sweep attribute in modelling.
        
        - wakeSetup : wks                (bool)          [edit]
            Like the 'windSetup' and 'fanSetup', 'wakeSetup' sets certain values in the
            field to approximate the movement of air near a moving object, such as  a
            character's foot or hand. The values that are set are: inheritVelocity 1.0
            inheritRotation false componentOnly true enableSpread false speed 0.0
        
        - windSetup : wns                (bool)          [edit]
            This will set some of the values above in a way that approximates the effects of
            a basic wind. This allows the user to then change certain values as he/she
            wishes on the same command line. First the preset values get set, and then any
            other flags that were passed get taken into account. These are the values that
            get set to approximate 'wind': inheritVelocity 0.0 inheritRotation true
            componentOnly false enableSpread false                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.air`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'air'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Font(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PoseInterpolator(THlocatorShape):
    """
    class counterpart of mel function `poseInterpolator`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - addPose : ap                   (unicode)       []
        
        - deletePose : dp                (unicode)       []
        
        - drivers : d                    (bool)          []
        
        - exportPoses : ex               (unicode)       []
        
        - goToPose : gtp                 (unicode)       []
        
        - importPoses : im               (unicode)       []
        
        - index : i                      (bool)          []
        
        - kernelWidth : kw               (unicode)       []
        
        - mirror : m                     (unicode)       []
        
        - name : n                       (unicode)       []
        
        - pose : p                       (unicode, unicode) []
        
        - poseNames : pn                 (bool)          []
        
        - rename : rn                    (unicode, unicode) []
        
        - searchAndReplace : sr          (unicode, unicode) []
        
        - updatePose : up                (unicode)       []
        
        
        Derived from mel command `maya.cmds.poseInterpolator`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleDisplace(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleSurfAttach(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiCurveCollector(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NBase(Particle):
    def clearCachedTextureMap(self, val='True', **kwargs):
        """
        Clear the cached texture map for the specified attribute from the nBase.                                   
        
        
        Derived from mel command `maya.cmds.nBase`
        """
        pass
    def clearStart(self, val='True', **kwargs):
        """
        Indicates that start state should be cleared                               
        
        
        Derived from mel command `maya.cmds.nBase`
        """
        pass
    def stuffStart(self, val='True', **kwargs):
        """
        Indicates that current state should be stuffed into the start state                                
        
        
        Derived from mel command `maya.cmds.nBase`
        """
        pass
    def textureToVertex(self, val='True', **kwargs):
        """
        Transfer the texture map data for the specified attribute into the related per-vertex attribute.                                   Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nBase`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Edits one or more nBase objects. Note that nBase objects include nCloth, nRigid
        and nParticle objects, but the options on this command do not currently apply to
        nParticle objects.
        
        Flags:
        - clearCachedTextureMap : cct    (unicode)       [create,edit]
            Clear the cached texture map for the specified attribute from the nBase.
        
        - clearStart : cs                (bool)          [create,edit]
            Indicates that start state should be cleared
        
        - stuffStart : ss                (bool)          [create,edit]
            Indicates that current state should be stuffed into the start state
        
        - textureToVertex : ttv          (unicode)       [create,edit]
            Transfer the texture map data for the specified attribute into the related per-
            vertex attribute.                                   Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.nBase`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Lattice(ControlPoint):
    def after(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node after the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def afterReference(self, val='True', **kwargs):
        """
        The -afterReference flag is used to specify deformer ordering in a hybrid way that choses between -before and -after automatically. If the geometry being deformed is referenced then the -after mode is used when adding the new deformer, otherwise the -before mode is used. The net effect when using -afterReference to build deformer chains is that internal shape nodes in the deformer chain will only appear at reference file boundaries, leading to lightweight deformer networks that may be more amicable to reference swapping.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def before(self, val='True', **kwargs):
        """
        If the default behavior for insertion/appending into/onto the existing chain is not the desired behavior then this flag can be used to force the command to place the deformer node before the selected node in the chain even if a new geometry shape has to be created in order to do so. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def frontOfChain(self, val='True', **kwargs):
        """
        This command is used to specify that the new deformer node should be placed ahead (upstream) of existing deformer and skin nodes in the shape's history (but not ahead of existing tweak nodes). The input to the deformer will be the upstream shape rather than the visible downstream shape, so the behavior of this flag is the most intuitive if the downstream deformers are in their reset (hasNoEffect) position when the new deformer is added. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def getDeformerTools(self, **kwargs):
        """
        Returns the name of the deformer tool objects (if any) as string string ...                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def getDivisions(self):
        """
        Get the number of divisions in the lattice
        
        Returns:
        Tuple['int', 'int', 'int']
        
        Derived from api method `maya.OpenMayaAnim.MFnLattice.getDivisions`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        Puts the deformation set in a deform partition.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def getFreezeMapping(self, **kwargs):
        """
        The base position of the geometries points is fixed at the time this flag is set.  When mapping is frozen, moving the geometry with respect to the lattice will not cause the deformation to be recomputed.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def getGeometry(self, **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def getGeometryIndices(self, **kwargs):
        """
        Complements the -geometry flag in query mode. Returns the multi index of each geometry.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def getLdivisions(self, **kwargs):
        """
        Set the number of local lattice slices in x, y, z.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def latticeReset(self, val='True', **kwargs):
        """
        Reset the lattice to match its base position. This will undo any deformations that the lattice is causing. The lattice will only deform points that are enclosed within the lattice's reset (base) position.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def parallel(self, val='True', **kwargs):
        """
        Inserts the new deformer in a parallel chain to any existing deformers in the history of the object. A blendShape is inserted to blend the parallel results together. Works in create mode (and edit mode if the deformer has no geometry added yet).                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def point(self, s, t, u):
        """
        Returns the point in the lattice that is at the given indices
        
        Parameters:
        s : 'int'
            s index
        t : 'int'
            t index
        u : 'int'
            u index
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMayaAnim.MFnLattice.point`
        """
        pass
    def prune(self, val='True', **kwargs):
        """
        Removes any points not being deformed by the deformer in its current configuration from the deformer set.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def remove(self, val='True', **kwargs):
        """
        Specifies that objects listed after the -g flag should be removed from this deformer.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def removeTweaks(self, val='True', **kwargs):
        """
        Remove any lattice deformations caused by moving lattice points. Translations/rotations and scales on the lattice itself are not removed.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def reset(self, sSize='1.0', tSize='1.0', uSize='1.0'):
        """
        Reset the lattice points to a uniform parallelipiped shape with the specified dimensions: sSize x tSize x uSize
        
        Parameters:
        sSize : 'float'
            size in s dimension
        tSize : 'float'
            size in t dimension
        uSize : 'float'
            size in u dimension
        
        Derived from api method `maya.OpenMayaAnim.MFnLattice.reset`
        """
        pass
    def setDivisions(self, s, t, u):
        """
        Set the number of divisions in the lattice
        
        Parameters:
        s : 'int'
            divisions in s dimension
        t : 'int'
            divisions in t dimension
        u : 'int'
            divisions in u dimension
        
        Derived from api method `maya.OpenMayaAnim.MFnLattice.setDivisions`
        """
        pass
    def setFreezeMapping(self, val='True', **kwargs):
        """
        The base position of the geometries points is fixed at the time this flag is set.  When mapping is frozen, moving the geometry with respect to the lattice will not cause the deformation to be recomputed.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def setGeometry(self, val='True', **kwargs):
        """
        The specified object will be added to the list of objects being deformed by this deformer object, unless the -rm flag is also specified. When queried, this flag returns string string string ...                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    def setLdivisions(self, val='True', **kwargs):
        """
        Set the number of local lattice slices in x, y, z.                  
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a lattice deformer that will deform the selected objects.
        If the object centered flag is used, the initial lattice will fit around the
        selected objects. The lattice will be selected when the command is completed.
        The lattice deformer has an associated base lattice. Only objects which are
        contained by the base lattice will be deformed by the lattice.
        
        Flags:
        - after : af                     (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node after the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - afterReference : ar            (bool)          [create,edit]
            The -afterReference flag is used to specify deformer ordering in a hybrid way
            that choses between -before and -after automatically. If the geometry being
            deformed is referenced then the -after mode is used when adding the new
            deformer, otherwise the -before mode is used. The net effect when using
            -afterReference to build deformer chains is that internal shape nodes in the
            deformer chain will only appear at reference file boundaries, leading to
            lightweight deformer networks that may be more amicable to reference swapping.
        
        - before : bf                    (bool)          [create,edit]
            If the default behavior for insertion/appending into/onto the existing chain is
            not the desired behavior then this flag can be used to force the command to
            place the deformer node before the selected node in the chain even if a new
            geometry shape has to be created in order to do so. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - commonParent : cp              (bool)          [create]
            Group the base lattice and the deformed lattice under a common transform. This
            means that you can resize the lattice without affecting the deformation by
            resizing the common transform.
        
        - deformerTools : dt             (bool)          [query]
            Returns the name of the deformer tool objects (if any) as string string ...
        
        - divisions : dv                 (int, int, int) [create,query,edit]
            Set the number of lattice slices in x, y, z. Default is 2, 5, 2. When queried,
            this flag returns float float float. When you change the number of divisions,
            any tweaking or animation of lattice points must be redone.
        
        - dualBase : db                  (bool)          [create]
            Create a special purpose ffd deformer node which accepts 2 base lattices. The
            default is off which results in the creation of a normal ffd deformer node.
            Intended for internal usage only.
        
        - exclusive : ex                 (unicode)       [create,query]
            Puts the deformation set in a deform partition.
        
        - freezeMapping : fm             (bool)          [create,query,edit]
            The base position of the geometries points is fixed at the time this flag is
            set.  When mapping is frozen, moving the geometry with respect to the lattice
            will not cause the deformation to be recomputed.
        
        - frontOfChain : foc             (bool)          [create,edit]
            This command is used to specify that the new deformer node should be placed
            ahead (upstream) of existing deformer and skin nodes in the shape's history (but
            not ahead of existing tweak nodes). The input to the deformer will be the
            upstream shape rather than the visible downstream shape, so the behavior of this
            flag is the most intuitive if the downstream deformers are in their reset
            (hasNoEffect) position when the new deformer is added. Works in create mode (and
            edit mode if the deformer has no geometry added yet).
        
        - geometry : g                   (unicode)       [query,edit]
            The specified object will be added to the list of objects being deformed by this
            deformer object, unless the -rm flag is also specified. When queried, this flag
            returns string string string ...
        
        - geometryIndices : gi           (bool)          [query]
            Complements the -geometry flag in query mode. Returns the multi index of each
            geometry.
        
        - ignoreSelected : ignoreSelected (bool)          [create]
            Tells the command to not deform objects on the current selection list
        
        - includeHiddenSelections : ihs  (bool)          [create]
            Apply the deformer to any visible and hidden objects in the selection list.
            Default is false.
        
        - latticeReset : lr              (bool)          [edit]
            Reset the lattice to match its base position. This will undo any deformations
            that the lattice is causing. The lattice will only deform points that are
            enclosed within the lattice's reset (base) position.
        
        - ldivisions : ldv               (int, int, int) [create,query,edit]
            Set the number of local lattice slices in x, y, z.
        
        - name : n                       (unicode)       [create]
            Used to specify the name of the node being created.
        
        - objectCentered : oc            (bool)          [create]
            Centers the lattice around the selected object(s) or components. Default is off
            which centers the lattice at the origin.
        
        - outsideFalloffDistance : ofd   (float)         [create]
            Set the falloff distance used when the setting for transforming points outside
            of the base lattice is set to 2. The distance value is a positive number which
            specifies the size of the falloff distance as a multiple of the base lattice
            size, thus a value of 1.0 specifies that only points up to the base lattice
            width/height/depth away are transformed. A value of 0.0 is equivalent to an
            outsideLattice value of 0 (i.e. no points outside the base lattice are
            transformed). A huge value is equivalent to transforming an outsideLattice value
            of 1 (i.e. all points are transformed).
        
        - outsideLattice : ol            (int)           [create]
            Set the mode describing how points outside the base lattice are transformed. 0
            (the default) specifies that no outside points are transformed. 1 specifies that
            all outside points are transformed, and 2 specifies that only those outside
            points which fall within the falloff distance(see the
            -ofd/outsideFalloffDistance flag) are transformed. When querying, the current
            setting for the lattice is returned.
        
        - parallel : par                 (bool)          [create,edit]
            Inserts the new deformer in a parallel chain to any existing deformers in the
            history of the object. A blendShape is inserted to blend the parallel results
            together. Works in create mode (and edit mode if the deformer has no geometry
            added yet).
        
        - position : pos                 (float, float, float) [create]
            Used to specify the position of the newly created lattice.
        
        - prune : pr                     (bool)          [edit]
            Removes any points not being deformed by the deformer in its current
            configuration from the deformer set.
        
        - remove : rm                    (bool)          [edit]
            Specifies that objects listed after the -g flag should be removed from this
            deformer.
        
        - removeTweaks : rt              (bool)          [edit]
            Remove any lattice deformations caused by moving lattice points.
            Translations/rotations and scales on the lattice itself are not removed.
        
        - rotation : ro                  (float, float, float) [create]
            Used to specify the initial rotation of the newly created lattice.
        
        - scale : s                      (float, float, float) [create]
            Used to specify the initial scale of the newly created lattice.
        
        - split : sp                     (bool)          [create,edit]
            Branches off a new chain in the dependency graph instead of inserting/appending
            the deformer into/onto an existing chain. Works in create mode (and edit mode if
            the deformer has no geometry added yet).                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.lattice`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AssemblyReference(THassembly):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SurfaceShape(ControlPoint):
    __melnode__ = []
    
    
    __readonly__ = {}


class OrthoGrid(SketchPlane):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLightPortal(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleFalloff(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiPhotometricLight(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmConnectivity(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiMeshLight(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiLightBlocker(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NurbsCurve(CurveShape):
    def area(self, tolerance='0.001'):
        """
        This method returns the area bounded by this curve. The curve must be closed and planar.
        
        Parameters:
        tolerance : 'float'
            The amount of error (epsilon value) in the calculation
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.area`
        """
        pass
    def closestPoint(self, toThisPoint, param='None', tolerance='0.001', space="'preTransform'"):
        """
        This method determines the closest point on the curve to the given point.
        
        Parameters:
        toThisPoint : 'Point'
            The point to test
        param : 'float'
            If non-null, on successful returns this will contain the parameter value of the returned point.
        tolerance : 'float'
            The amount of error (epsilon value) to allow in the calculation
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.closestPoint`
        """
        pass
    def copy(self, source, parentOrOwner="'MObject::kNullObj'"):
        """
        This method creates a copy of a nurbs curve.
        
        Parameters:
        source : 'PyNode'
            the curve to be copied
        parentOrOwner : 'PyNode'
            the DAG parent or kNurbsCurveData the new curve will belong to
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.copy`
        """
        pass
    def createWithEditPoints(self, editPoints, degree, form, create2D, createRational, uniformParam, parentOrOwner="'MObject::kNullObj'"):
        """
        This method creates a nurbs curve from the given edit points and sets this function set to operate on the new curve.
        
        Parameters:
        editPoints : List['Point']
            an array of edit points
        degree : 'int'
            the degree to create the curve with
        form : 'NurbsCurve.Form'
            either kOpen, kClosed, kPeriodic
        
            values: 'open', 'closed', 'periodic'
        create2D : 'bool'
            true means that the Z-coordinates of the controlVertices will be ignored, giving a curve in the local XY plane
        createRational : 'bool'
            true means curve being created will be rational
        uniformParam : 'bool'
            true means curve being created will have uniform parameterization, false means chord length
        parentOrOwner : 'PyNode'
            the DAG parent or kNurbsCurveData the new curve will belong to
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.createWithEditPoints`
        """
        pass
    def cvs(self, startIndex, endIndex):
        """
        Returns a contiguous group of CVs as a component. MItCurveCV can be used to examine or modify the returned CVs.
        
        Parameters:
        startIndex : 'int'
            the start index for the CVs to return
        endIndex : 'int'
            the end index for the CVs to return
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.cvs`
        """
        pass
    def degree(self):
        """
        Return the degree of this curve. If the degree cannot be determined then 0 is returned.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.degree`
        """
        pass
    def distanceToPoint(self, pt, space="'preTransform'"):
        """
        Returns the distance from the given point to the point on the curve which is closest to it.
        
        Parameters:
        pt : 'Point'
            The point to calculate the distance to
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MSpace.distanceToPoint`
        """
        pass
    def findLengthFromParam(self, param):
        """
        Returns the length along the curve corresponding to a given parameter value on the curve. If the length cannot be found for the given parameter value then ReturnStatus is set to kInvalidParameter and a length of zero is returned.
        
        Parameters:
        param : 'float'
            Parameter value on the curve
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.findLengthFromParam`
        """
        pass
    def findParamFromLength(self, partLength):
        """
        Returns the parameter value corresponding to a given length along the curve. If the parameter value cannot be found for the given length then ReturnStatus is set to kInvalidParameter and the parameter for the end point of the curve is returned.
        
        Parameters:
        partLength : 'float'
            Length along the curve to find parameter value at
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.findParamFromLength`
        """
        pass
    def form(self):
        """
        This method returns the form of the curve. The curve can be open, closed, or periodic.
        
        Returns:
        'NurbsCurve.Form'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.form`
        """
        pass
    def getCV(self, index, space="'preTransform'"):
        """
        Get the CV at the given index.
        
        Parameters:
        index : 'int'
            The index of the CV that will be retrieved
        space : 'Space.Space'
            Specifies the coordinate system for this operation par Status Codes: MS::kSuccess The CV was successfully set MS::kInvalidParameter CV index out of range MS::kFailure Object error
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.getCV`
        """
        pass
    def getCVs(self, space="'preTransform'"):
        """
        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.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation par Status Codes: MS::kSuccess The method was successful MS::kInvalidParameter Cannot do world space transform MS::kFailure An object error has occurred
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        List['Point']
        
        Derived from api method `maya.OpenMaya.MSpace.getCVs`
        """
        pass
    def getDerivativesAtParm(self, param, space):
        """
        Evaluate the curve at the given parameter returning the position, first derivative and optionally the second derivative. Derivatives are not normalized.
        
        Parameters:
        param : 'float'
            U parameter value to evaluate
        space : 'Space.Space'
            Coordinate space for the returned vectors
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        Tuple['Point', 'Vector', 'Vector']
        
        Derived from api method `maya.OpenMaya.MSpace.getDerivativesAtParm`
        """
        pass
    def getKnot(self, index):
        """
        Get the parameter value of the specified knot for this curve. Knot indices range from 0 to numKnots() - 1
        
        Parameters:
        index : 'int'
            The knot index
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.knot`
        """
        pass
    def getKnotDomain(self):
        """
        Return the range corresponding to the maximum and minimum parameter values for this curve.
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.getKnotDomain`
        """
        pass
    def getKnots(self):
        """
        This method retrieves a copy of the knot array for this curve.
        
        Returns:
        List['float']
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.getKnots`
        """
        pass
    def getParamAtPoint(self, atThisPoint, space="'preTransform'"):
        """
        This method retrieves the parameter value corresponding to the given point on the curve.
        
        Parameters:
        atThisPoint : 'Point'
            Point to check
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MSpace.getParamAtPoint`
        """
        pass
    def getPointAtParam(self, param, space="'preTransform'"):
        """
        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.
        
        Parameters:
        param : 'float'
            The parameter value that we are examining
        space : 'Space.Space'
            Specifies the coordinate system for this operation par Status Codes: MS::kSuccess The method was successful. MS::kInvalidParameter Invalid parameter specified. MS::kFailure An object error has occurred.
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.getPointAtParam`
        """
        pass
    def hasHistoryOnCreate(self):
        """
        This method determines if the shape was created with history.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.hasHistoryOnCreate`
        """
        pass
    def isParamOnCurve(self, param):
        """
        Determines whether the specified parameter value is within the bounds of the knot vector of this curve
        
        Parameters:
        param : 'float'
            The parameter value to check
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.isParamOnCurve`
        """
        pass
    def isPlanar(self, planeNormal='None'):
        """
        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.
        
        Parameters:
        planeNormal : 'Vector'
            Normal to the plane containing this curve
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.isPlanar`
        """
        pass
    def isPointOnCurve(self, point, tolerance='0.001', space="'preTransform'"):
        """
        Determines whether the given point is on this curve.
        
        Parameters:
        point : 'Point'
            The point to test
        tolerance : 'float'
            The amount of error (epsilon value) in the calculation
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MSpace.isPointOnCurve`
        """
        pass
    def length(self, tolerance='0.001'):
        """
        Return the arc length of this curve or 0.0 if it cannot be computed.
        
        Parameters:
        tolerance : 'float'
            The amount of error (epsilon value) in the calculation
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.length`
        """
        pass
    def 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.
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.makeMultipleEndKnots`
        """
        pass
    def normal(self, param, space="'preTransform'"):
        """
        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.
        
        Parameters:
        param : 'float'
            The parameter of the point on the curve from which to get the normal
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.normal`
        """
        pass
    def numCVs(self, editableOnly='True'):
        """
        Returns the number of CVs.
        
        :Parameters:
        editableOnly : `bool`
            If editableOnly evaluates to True (default), then this will return
            the number of cvs that can be actually edited (and also the highest
            index that may be used for cv's - ie, if
                myCurve.numCVs(editableOnly=True) == 4
            then allowable cv indices go from
                myCurve.cv[0] to mySurf.cv[3]
        
            If editablyOnly is False, then this will return the underlying
            number of cvs used to define the mathematical curve -
            degree + numSpans.
        
            These will only differ if the form is 'periodic', in which
            case the editable number will be numSpans (as the last 'degree'
            cv's are 'locked' to be the same as the first 'degree' cvs).
            In all other cases, the number of cvs will be degree + numSpans.
        
        :Examples:
            >>> from pymel.core import *
            >>> # a periodic curve
            >>> myCurve = curve(name='periodicCurve1', d=3, periodic=True, k=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1)] )
            >>> myCurve.cv
            NurbsCurveCV(u'periodicCurveShape1.cv[0:7]')
            >>> myCurve.numCVs()
            8
            >>> myCurve.numCVs(editableOnly=False)
            11
            >>>
            >>> # an open curve
            >>> myCurve = curve(name='openCurve1', d=3, periodic=False, k=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1)] )
            >>> myCurve.cv
            NurbsCurveCV(u'openCurveShape1.cv[0:10]')
            >>> myCurve.numCVs()
            11
            >>> myCurve.numCVs(editableOnly=False)
            11
        
        :rtype: `int`
        """
        pass
    def numEPs(self, editableOnly='True'):
        """
        Returns the number of EPs.
        
        :Examples:
            >>> from pymel.core import *
            >>> # a periodic curve
            >>> myCurve = curve(name='periodicCurve2', d=3, periodic=True, k=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1)] )
            >>> myCurve.ep
            NurbsCurveEP(u'periodicCurveShape2.ep[0:7]')
            >>> myCurve.numEPs()
            8
            >>>
            >>> # an open curve
            >>> myCurve = curve(name='openCurve2', d=3, periodic=False, k=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1)] )
            >>> myCurve.ep
            NurbsCurveEP(u'openCurveShape2.ep[0:8]')
            >>> myCurve.numEPs()
            9
        
        Returns
        -------
        int
        """
        pass
    def numKnots(self):
        """
        Return the number of knots for this curve. If the number of knots cannot be determined then 0 is returned.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.numKnots`
        """
        pass
    def numSpans(self):
        """
        Return the number of spans for this curve. If the number of spans cannot be determined then 0 is returned.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.numSpans`
        """
        pass
    def rebuild(self, endKnots='0', keepEndPoints='True', keepTangents='True', keepControlPoints='False', tolerance='0.01'):
        """
        This method rebuilds a new curve based on the current curve and parameters.
        
        Parameters:
        endKnots : 'int'
            End conditions for the curve 0 - uniform end knots, 1 - multiple end knots
        keepEndPoints : 'bool'
            If true, keep the endpoints the same
        keepTangents : 'bool'
            If true, keep the end tangents the same
        keepControlPoints : 'bool'
            If true, the CVs will remain the same.
        tolerance : 'float'
            The tolerance with which to rebuild
        
        
        Returns:
        Tuple['PyNode', 'int', 'int', 'int']
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.rebuild`
        """
        pass
    def removeKnot(self, atThisParam, removeAll='False'):
        """
        Remove one or more knots at the given parameter.
        
        Parameters:
        atThisParam : 'float'
            Status code
        removeAll : 'bool'
            How to handle multiple knots at the same param. par Status Codes: MS::kSuccess The method was successful MS::kInvalidParameter Parameter value is out of range MS::kFailure An object error has occurred
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.removeKnot`
        """
        pass
    def reverse(self, constructionHistory='False'):
        """
        This method reverse the curve direction.
        
        Parameters:
        constructionHistory : 'bool'
            This parameter has no effect. Regardless of how it is set, if the function set was initialized with the DAG path of a curve node which already has history, then the reverse operation will be added into that history, otherwise the reverse operation will be applied directly to the curve's data and no history will be left behind.
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.reverse`
        """
        pass
    def setCV(self, index, pt, space="'preTransform'"):
        """
        Set the CV at the given index to the given point. The method updateCurve should be called to trigger changes in the curve.
        
        Parameters:
        index : 'int'
            The index of the CV that will be changed
        pt : 'Point'
            The new value that the CV will take
        space : 'Space.Space'
            Specifies the coordinate system for this operation par Status Codes: MS::kSuccess The CV was successfully set MS::kInvalidParameter CV index out of range MS::kFailure Object error
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setCV`
        """
        pass
    def setCVs(self, array, space="'preTransform'"):
        """
        Set the CVs for this curve to the given points.
        
        Parameters:
        array : List['Point']
            The array of point values for the CVs
        space : 'Space.Space'
            Specifies the coordinate system for this operation par Status Codes: MS::kSuccess The method was successful. MS::kInvalidParameter Cannot do world space transform. MS::kFailure An object error has occurred.
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setCVs`
        """
        pass
    def setKnot(self, index, param):
        """
        Set the given knot's parameter value. Knot indices range from 0 to numKnots() - 1.
        
        Parameters:
        index : 'int'
            Index of the knot to be set
        param : 'float'
            The parameter value that the knot will take par Status Codes: MS::kSuccess The method was successful MS::kInvalidParameter Knot index out of range or new knot value breaks the non-decreasing requirement for the knot array. MS::kFailure An object error has occurred
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.setKnot`
        """
        pass
    def setKnots(self, array, startIndex, endIndex):
        """
        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.
        
        Parameters:
        array : List['float']
            a double array of knot points
        startIndex : 'int'
            the starting index of the knots to be altered.
        endIndex : 'int'
            the ending index of the knots to be altered. par Status Codes: MS::kSuccess The method was successful MS::kInvalidParameter Invalid start or end indices, or the length of the array is not sufficient to fill the range given, or the knots are in decreasing order. MS::kFailure An object error has occurred
        
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.setKnots`
        """
        pass
    def tangent(self, param, space="'preTransform'"):
        """
        This method returns the tangent at the given parameter value on the curve. The resulting tangent vector is normalized.
        
        Parameters:
        param : 'float'
            The parameter of the point on the curve from which to get the tangent
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.tangent`
        """
        pass
    def updateCurve(self):
        """
        This method signals that this curve has changed and needs to be recalculated.
        Derived from api method `maya.OpenMaya.MFnNurbsCurve.updateCurve`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The curve command creates a new curve from a list of control vertices (CVs).  A
        string is returned containing the pathname to the newly created curve.  You can
        create a curve from points either in world space or object (local) space, either
        with weights or without. You can replace an existing curve by using the
        -r/replaceflag.  You can append a point to an existing curve by using the
        -a/appendflag. To create a curve-on-surface, use the curveOnSurface command. To
        change the degree of a curve, use the rebuildCurve command. To change the of
        parameter range curve, use the rebuildCurve command.
        
        Flags:
        - append : a                     (bool)          [create]
            Appends point(s) to the end of an existing curve. If you use this flag, you must
            specify the name of the curve to append to, at the end of the command.  (See
            examples below.)
        
        - bezier : bez                   (bool)          [create]
            The created curve will be a bezier curve.
        
        - degree : d                     (float)         [create]
            The degree of the new curve.  Default is 3.  Note that you need (degree+1) curve
            points to create a visible curve span.  eg. you must place 4 points for a degree
            3 curve.
        
        - editPoint : ep                 (float, float, float) [create]
            The x, y, z position of an edit point.  linearmeans that this flag can take
            values with units.  This flag can not be used with the -point or the
            -pointWeight flags.
        
        - knot : k                       (float)         [create]
            A knot value in a knot vector.  One flag per knot value. There must be
            (numberOfPoints + degree - 1) knots and the knot vector must be non-decreasing.
        
        - name : n                       (unicode)       [create]
            Name of the curve
        
        - objectSpace : os               (bool)          [create]
            Points are in object, or localspace.  This is the default. You cannot specify
            both -osand -wsin the same command.
        
        - periodic : per                 (bool)          [create]
            If on, creates a curve that is periodic.  Default is off.
        
        - point : p                      (float, float, float) [create]
            The x, y, z position of a point.  linearmeans that this flag can take values
            with units.
        
        - pointWeight : pw               (float, float, float, float) [create]
            The x,y,z and w values of a point, where the w is a weight value. A rational
            curve will be created if this flag is used. linearmeans that this flag can take
            values with units.
        
        - replace : r                    (bool)          [create]
            Replaces an entire existing curve. If you use this flag, you must specify the
            name of the curve to replace, at the end of the command.  (See examples below.)
        
        - worldSpace : ws                (bool)          [create]
            Points are in world space.  The default is -os. You cannot specify both -osand
            -wsin the same command.                  Flag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.curve`
        """
        pass
    Form = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'curve'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SphereLocator(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BifrostContainer(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class OrientationMarker(PositionMarker):
    __melnode__ = []
    
    
    __readonly__ = {}


class AssemblyDefinition(THassembly):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GroundPlane(SketchPlane):
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleSmartCollide(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Flight(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MaterialOverride(ConnectionOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DisplayPoints(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Falloff(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ConnectionUniqueOverride(ConnectionOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class ShaderOverride(ConnectionOverride):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class IgmDescription(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SnapshotShape(ControlPoint):
    __melnode__ = []
    
    
    __readonly__ = {}


class NonExtendedLightShapeNode(NonAmbientLightShapeNode):
    def getCastSoftShadows(self):
        """
        Retrieves the value of the "castSoftShadows" attribute of a non-extended light node. This attribute determines whether or not the light casts soft shadows.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.castSoftShadows`
        """
        pass
    def getDepthMapBias(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.depthMapBias`
        """
        pass
    def getDepthMapFilterSize(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.depthMapFilterSize`
        """
        pass
    def getDepthMapFocus(self):
        """
        Retrieves the value of the "depthMapFocus" attribute of a light node. This attribute represents the depth map's field of view.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.depthMapFocus`
        """
        pass
    def getDepthMapResolution(self):
        """
        Retrieves the value of the "depthMapResolution" attribute of a light node. This attribute determines the resolution of the depth map for this light.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.depthMapResolution`
        """
        pass
    def getDepthMapWidthFocus(self):
        """
        Retrieves the value of the "depthMapWidthFocus" attribute of a light node. This attribute is used to scale the depth map within the area of the light's illumination.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.depthMapWidthFocus`
        """
        pass
    def getShadowRadius(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.shadowRadius`
        """
        pass
    def getUseDepthMapAutoFocus(self):
        """
        Retrieves the value of the "useDepthMapAutoFocus" attribute of a non-extended light node. This attribute determines whether to automatically scale the depth map so that it only fills the area of the light's illumination that contains shadow casting objects.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.useDepthMapAutoFocus`
        """
        pass
    def getUseDepthMapShadows(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.useDepthMapShadows`
        """
        pass
    def setCastSoftShadows(self, cast_soft_shadows):
        """
        Sets the value of the "castSoftShadows" attribute of a non-extended light node.
        
        Parameters:
        cast_soft_shadows : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setCastSoftShadows`
        """
        pass
    def setDepthMapBias(self, depth_map_bias):
        """
        Sets the value of the "depthMapBias" attribute of a light node.
        
        Parameters:
        depth_map_bias : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setDepthMapBias`
        """
        pass
    def setDepthMapFilterSize(self, depth_map_filter_size):
        """
        Sets the value of the "depthMapFilterSize" attribute of a light node.
        
        Parameters:
        depth_map_filter_size : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setDepthMapFilterSize`
        """
        pass
    def setDepthMapFocus(self, depth_map_focus):
        """
        Sets the value of the "depthMapFocus" attribute of a light node.
        
        Parameters:
        depth_map_focus : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setDepthMapFocus`
        """
        pass
    def setDepthMapResolution(self, depth_map_resolution):
        """
        Sets the value of the "depthMapResolution" attribute of a light node.
        
        Parameters:
        depth_map_resolution : 'int'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setDepthMapResolution`
        """
        pass
    def setDepthMapWidthFocus(self, depth_map_width_focus):
        """
        Sets the value of the "depthMapWidthFocus" attribute of a light node.
        
        Parameters:
        depth_map_width_focus : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setDepthMapWidthFocus`
        """
        pass
    def setShadowRadius(self, shadow_radius):
        """
        Sets the value of the "shadowRadius" attribute of a non-extended light node.
        
        Parameters:
        shadow_radius : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setShadowRadius`
        """
        pass
    def setUseDepthMapAutoFocus(self, use_depth_map_auto_focus):
        """
        Sets the value of the "useDepthMapAutoFocus" attribute of a non-extended light node.
        
        Parameters:
        use_depth_map_auto_focus : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setUseDepthMapAutoFocus`
        """
        pass
    def setUseDepthMapShadows(self, use_depth_map):
        """
        Sets the value of the "useDepthMapShadows" attribute of a non-extended light node.
        
        Parameters:
        use_depth_map : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnNonExtendedLight.setUseDepthMapShadows`
        """
        pass
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleDebug(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleDirection(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleObject(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleDisplay(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiAreaLight(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleSpline(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmPointsViewer(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_BulletSolver(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THfluidEmitter(FluidEmitter):
    __melnode__ = []
    
    
    __readonly__ = {}


class CMuscleKeepOut(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MASH_Points(THlocatorShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Mesh(SurfaceShape):
    """
    The Mesh class provides wrapped access to many API methods for querying and modifying meshes.  Be aware that
    modifying meshes using API commands outside of the context of a plugin is still somewhat uncharted territory,
    so proceed at our own risk.
    
    
    The component types can be accessed from the `Mesh` type (or it's transform) using the names you are
    familiar with from MEL:
    
        >>> from pymel.core import *
        >>> p = polySphere( name='theMoon', sa=7, sh=7 )[0]
        >>> p.vtx
        MeshVertex(u'theMoonShape.vtx[0:43]')
        >>> p.e
        MeshEdge(u'theMoonShape.e[0:90]')
        >>> p.f
        MeshFace(u'theMoonShape.f[0:48]')
    
    They are also accessible from their more descriptive alternatives:
    
        >>> p.verts
        MeshVertex(u'theMoonShape.vtx[0:43]')
        >>> p.edges
        MeshEdge(u'theMoonShape.e[0:90]')
        >>> p.faces
        MeshFace(u'theMoonShape.f[0:48]')
    
    As you'd expect, these components are all indexible:
    
        >>> p.vtx[0]
        MeshVertex(u'theMoonShape.vtx[0]')
    
    The classes themselves contain methods for getting information about the component.
    
        >>> p.vtx[0].connectedEdges()
        MeshEdge(u'theMoonShape.e[0,6,42,77]')
    
    This class provides support for python's extended slice notation. Typical maya ranges express a start and stop value separated
    by a colon.  Extended slices add a step parameter and can also represent multiple ranges separated by commas.
    Thus, a single component object can represent any collection of indices.
    
    This includes start, stop, and step values.
    
        >>> # do every other edge between 0 and 10
        >>> for edge in p.e[0:10:2]:
        ...     print edge
        ...
        theMoonShape.e[0]
        theMoonShape.e[2]
        theMoonShape.e[4]
        theMoonShape.e[6]
        theMoonShape.e[8]
        theMoonShape.e[10]
    
    Negative indices can be used for getting indices relative to the end:
    
        >>> p.edges  # the full range
        MeshEdge(u'theMoonShape.e[0:90]')
        >>> p.edges[5:-10]  # index 5 through to 10 from the last
        MeshEdge(u'theMoonShape.e[5:80]')
    
    Just like with python ranges, you can leave an index out, and the logical result will follow:
    
        >>> p.edges[:-10]  # from the beginning
        MeshEdge(u'theMoonShape.e[0:80]')
        >>> p.edges[20:]
        MeshEdge(u'theMoonShape.e[20:90]')
    
    Or maybe you want the position of every tenth vert:
    
        >>> for x in p.vtx[::10]:
        ...     print x, x.getPosition()
        ...
        theMoonShape.vtx[0] [0.270522117615, -0.900968849659, -0.339223951101]
        theMoonShape.vtx[10] [-0.704405844212, -0.623489797115, 0.339223951101]
        theMoonShape.vtx[20] [0.974927902222, -0.222520858049, 0.0]
        theMoonShape.vtx[30] [-0.704405784607, 0.623489797115, -0.339224010706]
        theMoonShape.vtx[40] [0.270522087812, 0.900968849659, 0.339223980904]
    
    
    To be compatible with Maya's range notation, these slices are inclusive of the stop index.
    
        >>> # face at index 8 will be included in the sequence
        >>> for f in p.f[4:8]: print f
        ...
        theMoonShape.f[4]
        theMoonShape.f[5]
        theMoonShape.f[6]
        theMoonShape.f[7]
        theMoonShape.f[8]
    
    >>> from pymel.core import *
    >>> obj = polyTorus()[0]
    >>> colors = []
    >>> for i, vtx in enumerate(obj.vtx):   # doctest: +SKIP
    ...     edgs=vtx.toEdges()              # doctest: +SKIP
    ...     totalLen=0                      # doctest: +SKIP
    ...     edgCnt=0                        # doctest: +SKIP
    ...     for edg in edgs:                # doctest: +SKIP
    ...         edgCnt += 1                 # doctest: +SKIP
    ...         l = edg.getLength()         # doctest: +SKIP
    ...         totalLen += l               # doctest: +SKIP
    ...     avgLen=totalLen / edgCnt        # doctest: +SKIP
    ...     #print avgLen                   # doctest: +SKIP
    ...     currColor = vtx.getColor(0)     # doctest: +SKIP
    ...     color = datatypes.Color.black   # doctest: +SKIP
    ...     # only set blue if it has not been set before
    ...     if currColor.b<=0.0:            # doctest: +SKIP
    ...         color.b = avgLen            # doctest: +SKIP
    ...     color.r = avgLen                # doctest: +SKIP
    ...     colors.append(color)            # doctest: +SKIP
    """
    
    
    
    def addHoles(self, faceIndex, vertexArray, loopCounts, mergeVertices='True', pointTolerance='1e-10'):
        """
        Adds holes to a mesh polygon.
        
        Parameters:
        faceIndex : 'int'
            Index of the face to which to add holes.
        vertexArray : List['Point']
            Array of ordered vertices that make up the polygon.
        loopCounts : List['int']
            Array of vertex loop counts.
        mergeVertices : 'bool'
            If true then if a vertex falls within pointTolerance of an existing vertex then the existing vertex is reused.
        pointTolerance : 'float'
            Specifies how close verticies have to be to before they are merged. This merging is only done if mergeVerticies is true.
        
        Derived from api method `maya.OpenMaya.MFnMesh.addHoles`
        """
        pass
    def area(*args, **kwargs):
        """
        returns the surface area of the object's faces in local space as a float                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def assignColor(self, polygonId, vertexIndex, colorId, colorSet='None'):
        """
        Maps a color value to a specified vertex of a polygon.
        
        Parameters:
        polygonId : 'int'
            The polygon (face) to map to
        vertexIndex : 'int'
            The face-relative (local) vertex id of the polygon to map to
        colorId : 'int'
            The color entry from the color list that will be mapped
        colorSet : 'unicode'
            Color set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.assignColor`
        """
        pass
    def assignColors(self, colorIds, colorSet='None'):
        """
        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.
        
        Parameters:
        colorIds : List['int']
            The color indices to be mapped to each polygon-vertex
        colorSet : 'unicode'
            Color set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.assignColors`
        """
        pass
    def assignUV(self, polygonId, vertexIndex, uvId, uvSet='None'):
        """
        Maps a texture coordinate to a specified vertex of a polygon.
        
        Parameters:
        polygonId : 'int'
            The polygon (face) to map to
        vertexIndex : 'int'
            The face-relative (local) vertex id of the polygon to map to
        uvId : 'int'
            The uv entry from the uv list that will be mapped
        uvSet : 'unicode'
            UV set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.assignUV`
        """
        pass
    def assignUVs(self, uvCounts, uvIds, uvSet='None'):
        """
        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.
        
        Parameters:
        uvCounts : List['int']
            The uv counts for each polygon (face) in the mesh
        uvIds : List['int']
            The uv indices to be mapped to each polygon-vertex
        uvSet : 'unicode'
            UV set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.assignUVs`
        """
        pass
    def booleanOps(self, op, meshes):
        """
        Computes the boolean between multiple meshes. The result is stored in the current MFnMesh instance. The current instance must point to a valid mesh, which can be empty. Such a mesh can result from using MFnMesh::create() for example.
        
        Parameters:
        op : 'Mesh.BoolOperation'
            Operation to perform (kUnion, kDifference or kIntersection)
        
            values: 'union', 'difference', 'intersection'
        meshes : List['PyNode']
            The meshes for the boolean operation
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.booleanOps`
        """
        pass
    def 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.
        Derived from api method `maya.OpenMaya.MFnMesh.cleanupEdgeSmoothing`
        """
        pass
    def clearColors(self, colorSet='None'):
        """
        This method clears out all color for the mesh, and leaves behind an empty color set.
        
        Parameters:
        colorSet : 'unicode'
            Color set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.clearColors`
        """
        pass
    def clearUVs(self, uvSet='None'):
        """
        This method clears out all texture coordinates for the mesh, and leaves behind an empty UVset.
        
        Parameters:
        uvSet : 'unicode'
            UV set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.clearUVs`
        """
        pass
    def createColorSet(self, colorSetName, modifier='None', instances='None'):
        """
        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.
        
        Parameters:
        colorSetName : 'unicode'
            The name of the color set to add.
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        instances : 'MUintArray'
            The instance number(s) for which the set should be added, or nullptr if the uv-set should be shared by all instances.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.createColorSetWithName`
        
        Aliases: createColorSet, createColorSetWithName
        """
        pass
    def createColorSetDataMesh(self, colorSetName, clamped='False', rep="'RGBA'"):
        """
        Parameters:
        colorSetName : 'unicode'
            
        clamped : 'bool'
            
        rep : 'Mesh.MColorRepresentation'
            
        
            values: 'alpha', 'RGB', 'RGBA'
        
        Derived from api method `maya.OpenMaya.MFnMesh.createColorSetDataMesh`
        """
        pass
    def createColorSetWithName(self, colorSetName, modifier='None', instances='None'):
        """
        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.
        
        Parameters:
        colorSetName : 'unicode'
            The name of the color set to add.
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        instances : 'MUintArray'
            The instance number(s) for which the set should be added, or nullptr if the uv-set should be shared by all instances.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.createColorSetWithName`
        
        Aliases: createColorSet, createColorSetWithName
        """
        pass
    def createColorSetWithNameDataMesh(self, colorSetName, clamped, rep):
        """
        Parameters:
        colorSetName : 'unicode'
            
        clamped : 'bool'
            
        rep : 'Mesh.MColorRepresentation'
            
        
            values: 'alpha', 'RGB', 'RGBA'
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.createColorSetWithNameDataMesh`
        """
        pass
    def createUVSet(self, uvSetName, modifier='None', instances='None'):
        """
        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.
        
        Parameters:
        uvSetName : 'unicode'
            The name of the uv set to add. If a new name needed to be generated then the new name will be returned by the function.
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        instances : 'MUintArray'
            The instance number(s) for which the set should be added, or nullptr if the uv-set should be shared by all instances.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.createUVSetWithName`
        
        Aliases: createUVSet, createUVSetWithName
        """
        pass
    def createUVSetDataMeshWithName(self, uvSetName):
        """
        Parameters:
        uvSetName : 'unicode'
            
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.createUVSetDataMeshWithName`
        """
        pass
    def createUVSetWithName(self, uvSetName, modifier='None', instances='None'):
        """
        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.
        
        Parameters:
        uvSetName : 'unicode'
            The name of the uv set to add. If a new name needed to be generated then the new name will be returned by the function.
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        instances : 'MUintArray'
            The instance number(s) for which the set should be added, or nullptr if the uv-set should be shared by all instances.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.createUVSetWithName`
        
        Aliases: createUVSet, createUVSetWithName
        """
        pass
    def deleteColorSet(self, colorSetName, modifier='None', currentSelection='None'):
        """
        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.
        
        Parameters:
        colorSetName : 'unicode'
            Name of the color set to delete
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        currentSelection : 'SelectionSet'
            Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.
        
        Derived from api method `maya.OpenMaya.MFnMesh.deleteColorSet`
        """
        pass
    def deleteUVSet(self, setName, modifier='None', currentSelection='None'):
        """
        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.
        
        Parameters:
        setName : 'unicode'
            Name of the uv set to delete
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        currentSelection : 'SelectionSet'
            Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.
        
        Derived from api method `maya.OpenMaya.MFnMesh.deleteUVSet`
        """
        pass
    def getAssignedUVs(self, uvSet='None'):
        """
        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.
        
        Parameters:
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        Tuple[List['int'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnMesh.getAssignedUVs`
        """
        pass
    def getAssociatedColorSetInstances(self, colorSetName):
        """
        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.
        
        Parameters:
        colorSetName : 'unicode'
            Name of color set to use
        
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getAssociatedColorSetInstances`
        
        Aliases: _getAssociatedColorSetInstances, getAssociatedColorSetInstances
        """
        pass
    def getAssociatedUVSetInstances(self, uvSetName):
        """
        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.
        
        Parameters:
        uvSetName : 'unicode'
            Name of uv set to use
        
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getAssociatedUVSetInstances`
        
        Aliases: _getAssociatedUVSetInstances, getAssociatedUVSetInstances
        """
        pass
    def getAssociatedUVSetTextures(self, uvSetName):
        """
        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.
        
        Parameters:
        uvSetName : 'unicode'
            Name of uv set to use
        
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getAssociatedUVSetTextures`
        """
        pass
    def getAxisAtPoint(self, pt, space="'preTransform'", uvSet='None'):
        """
        Find the point on the mesh which is closest to the given point, and return the axis at that point.
        
        Parameters:
        pt : 'Point'
            The point to be queried
        space : 'Space.Space'
            The coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        Tuple['Vector', 'Vector', 'Vector', 'int']
        
        Derived from api method `maya.OpenMaya.MSpace.getAxisAtPoint`
        """
        pass
    def getBinormals(self, space="'preTransform'", uvSet='None'):
        """
        Return the binormal vectors for all face vertices.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation.
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            The uv map set to calculate the binormals aginst.
        
        
        Returns:
        List['FloatVector']
        
        Derived from api method `maya.OpenMaya.MSpace.getBinormals`
        """
        pass
    def getCheckSamePointTwice(self):
        """
        Return true if checking for duplicate points is turned on. Return false otherwise.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.getCheckSamePointTwice`
        """
        pass
    def getClosestNormal(self, toThisPoint, space="'preTransform'", accelParams='None'):
        """
        Returns the closest point on this surface to the given point. This method also returns the surface normal at that point.
        
        Parameters:
        toThisPoint : 'Point'
            Point to be compared
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        accelParams : 'MMeshIsectAccelParams'
            optional acceleration parameters
        
        
        Returns:
        Tuple['Vector', 'int']
        
        Derived from api method `maya.OpenMaya.MSpace.getClosestNormal`
        """
        pass
    def getClosestPoint(self, toThisPoint, space="'preTransform'", accelParams='None'):
        """
        Returns the closest point on this surface to the given point.
        
        Parameters:
        toThisPoint : 'Point'
            Point to be compared
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        accelParams : 'MMeshIsectAccelParams'
            optional acceleration parameters
        
        
        Returns:
        Tuple['Point', 'int']
        
        Derived from api method `maya.OpenMaya.MSpace.getClosestPoint`
        """
        pass
    def getClosestPointAndNormal(self, toThisPoint, space="'preTransform'", accelParams='None'):
        """
        Returns the closest point on this surface to the given point. This method also returns the surface normal at that point.
        
        Parameters:
        toThisPoint : 'Point'
            Point to be compared
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        accelParams : 'MMeshIsectAccelParams'
            optional acceleration parameters
        
        
        Returns:
        Tuple['Point', 'Vector', 'int']
        
        Derived from api method `maya.OpenMaya.MSpace.getClosestPointAndNormal`
        """
        pass
    def getClosestUVs(self, toThisUVPoint, uvSet='None'):
        """
        Returns the IDs of the UVs on this surface which are nearest in uv space to the given uv set and coordinate. All these UVs locate at the same distance to the given coordinate.
        
        Parameters:
        toThisUVPoint : ('float', 'float')
            UV coordinate to be compared
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getClosestUVs`
        """
        pass
    def getColor(self, colorId, colorSet='None', defaultUnsetColor='None'):
        """
        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.
        
        Parameters:
        colorId : 'int'
            The element in the color list to examine
        colorSet : 'unicode'
            Color set to work with
        defaultUnsetColor : 'Color'
            default unset color
        
        
        Returns:
        'Color'
        
        Derived from api method `maya.OpenMaya.MFnMesh.getColor`
        """
        pass
    def getColorRepresentation(self, colorSet):
        """
        This method returns the color representation (RGB/RGBA/A) of a color set.
        
        Parameters:
        colorSet : 'unicode'
            Color set to work with
        
        
        Returns:
        'Mesh.MColorRepresentation'
        
        Derived from api method `maya.OpenMaya.MFnMesh.getColorRepresentation`
        """
        pass
    def getColorSetFamilyNames(self):
        """
        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.
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getColorSetFamilyNames`
        """
        pass
    def getColorSetNames(self):
        """
        Get the names of all of the colors sets on this object.
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getColorSetNames`
        """
        pass
    def getColors(self, colorSet='None', defaultUnsetColor='None'):
        """
        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.
        
        Parameters:
        colorSet : 'unicode'
            Color set to work with
        defaultUnsetColor : 'Color'
            Default unset color
        
        
        Returns:
        List['Color']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getColors`
        """
        pass
    def getCurrentColorSetName(self):
        """
        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.
        
        Parameters:
        instance : 'int'
            Instance of the mesh whose set we are interested in, or kMFnMeshInstanceUnspecified for the set which is shared across all instances.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.currentColorSetName`
        """
        pass
    def getCurrentUVSetName(self):
        """
        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.
        
        Parameters:
        instance : 'int'
            Instance of the mesh whose set we are interested in, or kMFnMeshInstanceUnspecified for the set which is shared across all instances.
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFnMesh.currentUVSetName`
        """
        pass
    def getDisplayColors(self):
        """
        Determine if the mesh node is set to display vertex colors.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.displayColors`
        """
        pass
    def getEdgeVertices(self, edgeId):
        """
        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.
        
        Parameters:
        edgeId : 'int'
            The edge to get the vertices for
        
        
        Returns:
        ('int', 'int')
        
        Derived from api method `maya.OpenMaya.MFnMesh.getEdgeVertices`
        """
        pass
    def getFaceNormalIds(self, faceIndex):
        """
        Return normal indices for all vertices for a given face. The normalIds can be used to index into an array returned by MFnMesh::getNormals();
        
        Parameters:
        faceIndex : 'int'
            Index of face (polygon) of interest
        
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getFaceNormalIds`
        """
        pass
    def getFaceUVSetNames(self, polygonId):
        """
        This method returns the list of UV sets mapped to a face.
        
        Parameters:
        polygonId : 'int'
            The polygon ID of the face of interest
        
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getFaceUVSetNames`
        """
        pass
    def getFaceVertexBinormal(self, faceIndex, vertexIndex, space="'preTransform'", uvSet='None'):
        """
        Return the binormal vector at a given face vertex.
        
        Parameters:
        faceIndex : 'int'
            Index of the face of interest
        vertexIndex : 'int'
            The object-relative (mesh-relative/global) vertex index
        space : 'Space.Space'
            Specifies the coordinate system for this operation.
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            The uv map set to calculate the binormals aginst.
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.getFaceVertexBinormal`
        """
        pass
    def getFaceVertexBinormals(self, faceIndex, space="'preTransform'", uvSet='None'):
        """
        Return all per-vertex-per-face binormals for a given face.
        
        Parameters:
        faceIndex : 'int'
            Index of the face (polygon) for which to retrive the binormals
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            The uv map set to calculate the binormals aginst.
        
        
        Returns:
        List['FloatVector']
        
        Derived from api method `maya.OpenMaya.MSpace.getFaceVertexBinormals`
        """
        pass
    def getFaceVertexColorIndex(self, faceIndex, localVertexIndex, colorSet='None'):
        """
        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.
        
        Parameters:
        faceIndex : 'int'
            The face to look for
        localVertexIndex : 'int'
            The face-relative (local) vertex id to look for
        colorSet : 'unicode'
            Color set to work with
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.getFaceVertexColorIndex`
        """
        pass
    def getFaceVertexColors(self, colorSet='None', defaultUnsetColor='None'):
        """
        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.
        
        Parameters:
        colorSet : 'unicode'
            Color set name
        defaultUnsetColor : 'Color'
            Default unset color
        
        
        Returns:
        List['Color']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getFaceVertexColors`
        """
        pass
    def getFaceVertexNormal(self, faceIndex, vertexIndex, space="'preTransform'"):
        """
        Return a per-vertex-per-face normal for a given face (polygon) and given vertex.
        
        Parameters:
        faceIndex : 'int'
            Index of the face of interest
        vertexIndex : 'int'
            The object-relative (mesh-relative/global) vertex index
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.getFaceVertexNormal`
        """
        pass
    def getFaceVertexTangent(self, faceIndex, vertexIndex, space="'preTransform'", uvSet='None'):
        """
        Return the normalized tangent vector at a given face vertex.
        
        Parameters:
        faceIndex : 'int'
            Index of the face of interest.
        vertexIndex : 'int'
            The object-relative (mesh-relative/global) vertex index.
        space : 'Space.Space'
            Specifies the coordinate system for this operation.
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            The uv map set to calculate the binormals aginst.
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.getFaceVertexTangent`
        """
        pass
    def getFaceVertexTangents(self, faceIndex, space="'preTransform'", uvSet='None'):
        """
        Return all per-vertex-per-face tangents for a given face.
        
        Parameters:
        faceIndex : 'int'
            Index of the face (polygon) for which to retrive the tangents
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            The uv map set to calculate the tangents aginst.
        
        
        Returns:
        List['FloatVector']
        
        Derived from api method `maya.OpenMaya.MSpace.getFaceVertexTangents`
        """
        pass
    def getHoles(self):
        """
        Retrieves a list of the holes in the polygon.
        
        Returns:
        Tuple['int', List['int'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnMesh.getHoles`
        """
        pass
    def getNormalIds(self):
        """
        Return normal indices for all vertices for a all faces. The normalIds can be used to index into an array returned by MFnMesh::getNormals();
        
        Returns:
        Tuple[List['int'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnMesh.getNormalIds`
        """
        pass
    def getNormals(self, space="'preTransform'"):
        """
        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.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        List['FloatVector']
        
        Derived from api method `maya.OpenMaya.MSpace.getNormals`
        """
        pass
    def getPoint(self, vertexId, space="'preTransform'"):
        """
        Get the position of the specified vertex in this mesh's vertex list.
        
        Parameters:
        vertexId : 'int'
            The object-relative (mesh-relative/global) index of the vertex to retrieve
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.getPoint`
        """
        pass
    def getPointAtUV(self, polygonId, uvPoint, space="'preTransform'", uvSet='None', tolerance='0.0'):
        """
        Return the position of the point at the given UV value in the current polygon.
        
        Parameters:
        polygonId : 'int'
            Search for uv on this face
        uvPoint : ('float', 'float')
            The UV value to try to locate
        space : 'Space.Space'
            The coordinate system to return "toThisPoint" in
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            UV set to work with
        tolerance : 'float'
            tolerance value to compare float data type
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.getPointAtUV`
        """
        pass
    def getPoints(self, space="'preTransform'"):
        """
        This method copies the vertex list for this mesh into the given point array.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        List['FloatPoint']
        
        Derived from api method `maya.OpenMaya.MSpace.getPoints`
        """
        pass
    def getPointsAtUV(self, uvPoint, space="'preTransform'", uvSet='None', tolerance='0.0'):
        """
        Return the positions of the points at the given UV value on the mesh.
        
        Parameters:
        uvPoint : ('float', 'float')
            UV coordinate to be compared
        space : 'Space.Space'
            The coordinate system to return "points" in
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            UV set to work with
        tolerance : 'float'
            tolerance value to compare float data type
        
        
        Returns:
        Tuple[List['int'], List['Point']]
        
        Derived from api method `maya.OpenMaya.MSpace.getPointsAtUV`
        """
        pass
    def getPolygonNormal(self, polygonId, space="'preTransform'"):
        """
        Return the normal at the given polygon. The returned normal is a per-polygon normal. See the class description for more information on normals.
        
        Parameters:
        polygonId : 'int'
            The polygon (face) to get the normal for
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.getPolygonNormal`
        """
        pass
    def getPolygonTriangleVertices(self, polygonId, triangleId):
        """
        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.
        
        Parameters:
        polygonId : 'int'
            The polygon to examine
        triangleId : 'int'
            The triangle within the polygon to examine (numbered from zero)
        
        
        Returns:
        ('int', 'int', 'int')
        
        Derived from api method `maya.OpenMaya.MFnMesh.getPolygonTriangleVertices`
        """
        pass
    def getPolygonUV(self, polygonId, vertexIndex, uvSet='None'):
        """
        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.
        
        Parameters:
        polygonId : 'int'
            The polygon (face) to examine
        vertexIndex : 'int'
            The face-relative (local) vertex id to examine
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getPolygonUV`
        """
        pass
    def getPolygonUVid(self, polygonId, vertexIndex, uvSet='None'):
        """
        Get the id of the specified texture coordinate for a vertex in a polygon.
        
        Parameters:
        polygonId : 'int'
            The polygon (face) to examine
        vertexIndex : 'int'
            The face-relative (local) vertex id to examine
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.getPolygonUVid`
        """
        pass
    def getPolygonVertices(self, polygonId):
        """
        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.
        
        Parameters:
        polygonId : 'int'
            The polygon to examine
        
        
        Returns:
        List['int']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getPolygonVertices`
        """
        pass
    def getTangentId(self, faceIndex, vertexIndex):
        """
        Return the tangent index for a given face vertex.
        
        Parameters:
        faceIndex : 'int'
            Index of the face of interest.
        vertexIndex : 'int'
            The object-relative (mesh-relative/global) vertex index.
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.getTangentId`
        """
        pass
    def getTangents(self, space="'preTransform'", uvSet='None'):
        """
        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.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation.
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            The uv map set to calculate the tangents against.
        
        
        Returns:
        List['FloatVector']
        
        Derived from api method `maya.OpenMaya.MSpace.getTangents`
        """
        pass
    def getTriangleOffsets(self):
        """
        Returns the number of triangles for every polygon face and the offset into the vertex indices array for each triangle vertex (see getVertices()). The triangleVertices array holds each vertex for each triangle in sequence, so it has three times as many elements as there are triangles. (i.e. three times the sum of the elements of the triangleCounts array)
        
        Returns:
        Tuple[List['int'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnMesh.getTriangleOffsets`
        """
        pass
    def getTriangles(self):
        """
        Returns the number of triangles for every polygon face and the vertex Ids of each triangle vertex. The triangleVertices array holds each vertex for each triangle in sequence, so it has three times as many elements as there are triangles. (i.e. three times the sum of the elements of the triangleCounts array)
        
        Returns:
        Tuple[List['int'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnMesh.getTriangles`
        """
        pass
    def getUV(self, uvId, uvSet='None'):
        """
        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.
        
        Parameters:
        uvId : 'int'
            The element in the uv list to examine
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getUV`
        """
        pass
    def getUVAtPoint(self, uvPoint, space='2', uvSet='None', returnClosestPolygon='False'):
        """
        Find the point closest to the given point, and return the UV value at that point.
        
        Parameters:
        pt : 'Point'
            The point to try to get UV for
        space : 'Space.Space'
            The coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        Tuple[('float', 'float'), 'int']
        
        Derived from api method `maya.OpenMaya.MSpace.getUVAtPoint`
        """
        pass
    def getUVSetFamilyNames(self):
        """
        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.
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getUVSetFamilyNames`
        """
        pass
    def getUVSetNames(self):
        """
        Get the names of all of the uv sets on this object.
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getUVSetNames`
        """
        pass
    def getUVSetsInFamily(self, familyName):
        """
        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.
        
        Parameters:
        familyName : 'unicode'
            The uv set family name
        
        
        Returns:
        List['list']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getUVSetsInFamily`
        """
        pass
    def getUVs(self, uvSet='None'):
        """
        This method copies the texture coordinate list for this mesh into the given uv arrays.
        
        Parameters:
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        Tuple[List['float'], List['float']]
        
        Derived from api method `maya.OpenMaya.MFnMesh.getUVs`
        """
        pass
    def getUvShellsIds(self, uvSet='None'):
        """
        Constructs an array of unique integer for each UV shell. This method let the user identify each connected piece of UV.
        
        Parameters:
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        Tuple[List['int'], 'int']
        
        Derived from api method `maya.OpenMaya.MFnMesh.getUvShellsIds`
        """
        pass
    def getVertexNormal(self, vertexId, angleWeighted, space="'preTransform'"):
        """
        This method is obsolete. [From Maya 2019]
        
        Parameters:
        vertexId : 'int'
            The object-relative (mesh-relative/global) vertex index to get the normal for
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.getVertexNormal`
        """
        pass
    def getVertices(self):
        """
        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.
        
        Returns:
        Tuple[List['int'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnMesh.getVertices`
        """
        pass
    def hasAlphaChannels(self, colorSet):
        """
        This method returns true if the color set has Alpha component.
        
        Parameters:
        colorSet : 'unicode'
            Color set to work with
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.hasAlphaChannels`
        """
        pass
    def hasColorChannels(self, colorSet):
        """
        This method returns if the color set has RGB components.
        
        Parameters:
        colorSet : 'unicode'
            Color set to work with
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.hasColorChannels`
        """
        pass
    def intersect(self, raySource, rayDirection, tolerance='1e-10', space="'preTransform'"):
        """
        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.
        
        Parameters:
        raySource : 'Point'
            Starting point for the ray
        rayDirection : 'Vector'
            Direction of the ray
        tolerance : 'float'
            Tolerance used in intersection calculation
        space : 'Space.Space'
            specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        Tuple['bool', List['Point'], List['int']]
        
        Derived from api method `maya.OpenMaya.MSpace.intersect`
        """
        pass
    def intersectFaceAtUV(self, toThisUVPoint, uvSet='None'):
        """
        Returns ID of the intersected face at given uv set and coordinate. If multiple faces are intersected, the first intersected one would be returned.
        
        Parameters:
        toThisUVPoint : ('float', 'float')
            UV coordinate to be compared
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.intersectFaceAtUV`
        """
        pass
    def isColorClamped(self, colorSet):
        """
        This method returns if the color set has its R,G,B,and A components clamped in the range from 0 to 1.
        
        Parameters:
        colorSet : 'unicode'
            Color set to work with
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isColorClamped`
        """
        pass
    def isColorSetPerInstance(self, name):
        """
        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.
        
        Parameters:
        name : 'unicode'
            The set name or set family name
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isColorSetPerInstance`
        """
        pass
    def isEdgeSmooth(self, edgeId):
        """
        This method determines if the specified edge is smooth (soft).
        
        Parameters:
        edgeId : 'int'
            The edge to be tested
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isEdgeSmooth`
        """
        pass
    def isNormalLocked(self, normalId):
        """
        Test if the normal for a face/vertex pairs is locked (user defined).
        
        Parameters:
        normalId : 'int'
            Normal to test.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isNormalLocked`
        """
        pass
    def isPolygonConvex(self, faceIndex):
        """
        This method determines if the specified polygon is convex.
        
        Parameters:
        faceIndex : 'int'
            The polygon to be tested
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isPolygonConvex`
        """
        pass
    def isPolygonUVReversed(self, polygonId, uvSet='None'):
        """
        This method determines if the winding order of texture coordinates (uv's) for specified polygon are reversed (clockwise)
        
        Parameters:
        polygonId : 'int'
            The polygon to be tested
        uvSet : 'unicode'
            UV set to work with
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isPolygonUVReversed`
        """
        pass
    def isRightHandedTangent(self, tangentId, uvSetName='None'):
        """
        Returns true if the normal, tangent and binormal form a right handed coordinate system. By default, Maya uses a right-handed system. Mirrored geometry can introduce a left-handed system.
        
        Parameters:
        tangentId : 'int'
            tangent index for a given face vertex
        uvSetName : 'unicode'
            Name of uv set to use
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isRightHandedTangent`
        """
        pass
    def isUVSetPerInstance(self, name):
        """
        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.
        
        Parameters:
        name : 'unicode'
            The set name or set family name
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.isUVSetPerInstance`
        """
        pass
    def lockFaceVertexNormals(self, faceList, vertexList):
        """
        Lock Normals for these face/vertex pairs
        
        Parameters:
        faceList : List['int']
            The faces to lock normal in
        vertexList : List['int']
            The corresponding object-relative (global) vertex indices to lock them for
        
        Derived from api method `maya.OpenMaya.MFnMesh.lockFaceVertexNormals`
        """
        pass
    def lockVertexNormals(self, vertexList):
        """
        Lock Shared Normals for these vertices.
        
        Parameters:
        vertexList : List['int']
            The object-relative (global) verticex ides to lock normals for
        
        Derived from api method `maya.OpenMaya.MFnMesh.lockVertexNormals`
        """
        pass
    def numColorSets(self, *args, **kwargs):
        """
        Returns the number of color sets for an object.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.numColorSets`
        """
        pass
    def numColors(self, colorSet='None'):
        """
        Returns the number of (vertex) color for this mesh. The color are stored in a list which is referenced by polygons requiring color on a per-polygon per-vertex basis. This method returns the number of elements in this list.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.numColors`
        """
        pass
    def numEdges(*args, **kwargs):
        """
        returns the number of edges as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def numFaceVertices(self, *args, **kwargs):
        """
        Returns the number of face-vertices for this mesh.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.numFaceVertices`
        """
        pass
    def numFaces(*args, **kwargs):
        """
        returns the number of faces as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def numNormals(self, *args, **kwargs):
        """
        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 ).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.numNormals`
        """
        pass
    def numPolygonVertices(self, polygonId):
        """
        Returns the number of vertices for the specified polygon.
        
        Parameters:
        polygonId : 'int'
            The polygon index
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.polygonVertexCount`
        
        Aliases: numPolygonVertices, polygonVertexCount
        """
        pass
    def numPolygons(self):
        """
        Returns the number of polygons for this mesh.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.numPolygons`
        
        Aliases: _numPolygons, numPolygons
        """
        pass
    def numSelectedEdges(*args, **kwargs):
        """
        returns the object's number of selected edges as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def numSelectedFaces(*args, **kwargs):
        """
        returns the object's number of selected faces as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def numSelectedTriangles(*args, **kwargs):
        """
        returns the number of triangles of selected components as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def numSelectedVertices(*args, **kwargs):
        """
        returns the object's number of selected vertices as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def numTriangles(*args, **kwargs):
        """
        returns the number of triangles as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def numUVSets(self, *args, **kwargs):
        """
        Returns the number of uv sets for an object.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.numUVSets`
        """
        pass
    def numUVs(self, *args, **kwargs):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.numUVs`
        """
        pass
    def numVertices(*args, **kwargs):
        """
        returns the number of vertices as an int                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    def onBoundary(self, polygonId):
        """
        A method to determines whether the specified face in the mesh is a boundary face.
        
        Parameters:
        polygonId : 'int'
            The polygon (face) to examine
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnMesh.onBoundary`
        """
        pass
    def polygonVertexCount(self, polygonId):
        """
        Returns the number of vertices for the specified polygon.
        
        Parameters:
        polygonId : 'int'
            The polygon index
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnMesh.polygonVertexCount`
        
        Aliases: numPolygonVertices, polygonVertexCount
        """
        pass
    def removeFaceColors(self, faceList):
        """
        Remove previously set color these faces. For each face, the color will be unset for each vertex-face component in the face.
        
        Parameters:
        faceList : List['int']
            The faces to remove color from
        
        Derived from api method `maya.OpenMaya.MFnMesh.removeFaceColors`
        """
        pass
    def removeFaceVertexColors(self, faceList, vertexList):
        """
        Remove colors for these face/vertex pairs
        
        Parameters:
        faceList : List['int']
            The faces to remove color for
        vertexList : List['int']
            The corresponding object-relative (mesh-relative/global) vertex indices to remove color for
        
        Derived from api method `maya.OpenMaya.MFnMesh.removeFaceVertexColors`
        """
        pass
    def removeVertexColors(self, vertexList):
        """
        Remove color from these vertices.
        
        Parameters:
        vertexList : List['int']
            The object-relative (mesh-relative/global) vertex indices to remove color from
        
        Derived from api method `maya.OpenMaya.MFnMesh.removeVertexColors`
        """
        pass
    def renameUVSet(self, origName, newName, modifier='None'):
        """
        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.
        
        Parameters:
        origName : 'unicode'
            The name of the uv set to change
        newName : 'unicode'
            The name to set the uv set to.
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        
        Derived from api method `maya.OpenMaya.MFnMesh.renameUVSet`
        """
        pass
    def setCheckSamePointTwice(self, check='True'):
        """
        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.
        
        Parameters:
        check : 'bool'
            true for checking, false otherwise
        
        Derived from api method `maya.OpenMaya.MFnMesh.setCheckSamePointTwice`
        """
        pass
    def setColor(self, colorId, color, colorSet='None'):
        """
        Sets the specified color values. The colorId is the element in the color list that will be set. If the colorId is greater than or equal to numColors() then the color list will be grown to accommodate the specified color.
        
        Parameters:
        colorId : 'int'
            The element in the color list to be set
        color : 'Color'
            The new color value that is to be set
        colorSet : 'unicode'
            Color set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.setColor`
        """
        pass
    def setColorClamped(self, colorSet, clamped):
        """
        Set the color set to be clamped.
        
        Parameters:
        colorSet : 'unicode'
            Color set to work with
        clamped : 'bool'
            If the color set should be set clamped
        
        Derived from api method `maya.OpenMaya.MFnMesh.setIsColorClamped`
        """
        pass
    def setColors(self, colorArray, colorSet='None'):
        """
        Sets all of the colors for this mesh. The color array must be at least as large as the current color set size. You can determine the color set size by calling numColors() for the default color set, or numColors(colorSet) for a named color set.
        
        Parameters:
        colorArray : List['Color']
            The array of color values to be set
        colorSet : 'unicode'
            The color set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.setColors`
        """
        pass
    def setCurrentColorSetName(self, setName, modifier='None', currentSelection='None'):
        """
        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.
        
        Parameters:
        setName : 'unicode'
            Name of color set to make "current"
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        currentSelection : 'SelectionSet'
            Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.
        
        Derived from api method `maya.OpenMaya.MFnMesh.setCurrentColorSetName`
        """
        pass
    def setCurrentUVSetName(self, setName, modifier='None', currentSelection='None'):
        """
        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.
        
        Parameters:
        setName : 'unicode'
            Name of uv set to make "current"
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        currentSelection : 'SelectionSet'
            Since this method may change the selection list, if you wish to undo its effects, you need to keep track of the current active selection. If this selection list is non-null, then the active selection list will be returned in this argument.
        
        Derived from api method `maya.OpenMaya.MFnMesh.setCurrentUVSetName`
        """
        pass
    def setDisplayColors(self, enable):
        """
        Set whether the mesh node should display vertex colors.
        
        Parameters:
        enable : 'bool'
            True to turn on color display, false to turn it off.
        
        Derived from api method `maya.OpenMaya.MFnMesh.setDisplayColors`
        """
        pass
    def setEdgeSmoothing(self, edgeId, smooth='True'):
        """
        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.
        
        Parameters:
        edgeId : 'int'
            The edge to set the smoothing information for
        smooth : 'bool'
            If true the edge will be smooth (soft), otherwise the edge will be hard.
        
        Derived from api method `maya.OpenMaya.MFnMesh.setEdgeSmoothing`
        """
        pass
    def setEdgeSmoothings(self, edgeIds, smooths):
        """
        This method sets the specified edges to be hard or smooth (soft). You must use the cleanupEdgeSmoothing method after all the desired edges on your mesh have had setEdgeSmoothing done. Use the updateSurface method to indicate the mesh needs to be redrawn.
        
        Parameters:
        edgeIds : List['int']
            The edges to set the smoothing information for
        smooths : List['int']
            If true the edges will be smooth (soft), otherwise the edges will be hard.
        
        Derived from api method `maya.OpenMaya.MFnMesh.setEdgeSmoothings`
        """
        pass
    def setFaceColor(self, color, faceIndex):
        """
        Set vertex-face Color for all vertices on this face.
        
        Parameters:
        color : 'Color'
            The color to set
        faceIndex : 'int'
            The face to set it for
        
        Derived from api method `maya.OpenMaya.MFnMesh.setFaceColor`
        """
        pass
    def setFaceColors(self, colors, faceList):
        """
        Set color for these faces. The color will be set for each vertex-face component of a face.
        
        Parameters:
        colors : List['Color']
            The colors to set
        faceList : List['int']
            The faces to set it for
        
        Derived from api method `maya.OpenMaya.MFnMesh.setFaceColors`
        """
        pass
    def setFaceVertexColor(self, color, faceIndex, vertexIndex, modifier='None'):
        """
        Set color for this vertex in this face.
        
        Parameters:
        color : 'Color'
            The color to set
        faceIndex : 'int'
            The face to set it for
        vertexIndex : 'int'
            The object-relative (mesh_relative/global) vertex index to set it for
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        
        Derived from api method `maya.OpenMaya.MFnMesh.setFaceVertexColor`
        """
        pass
    def setFaceVertexNormal(self, normalIn, faceId, vertexId, space="'preTransform'", modifier='None'):
        """
        Set Normal for this face/vertex pair
        
        Parameters:
        normalIn : 'Vector'
            The normal to set
        faceId : 'int'
            The face to set it for
        vertexId : 'int'
            The object-relative (mesh-relative/global) vertex index to set it for
        space : 'Space.Space'
            World space or Object space
        
            values: 'transform', 'preTransform', 'object', 'world'
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        
        Derived from api method `maya.OpenMaya.MSpace.setFaceVertexNormal`
        """
        pass
    def setNormals(self, normals, space="'preTransform'"):
        """
        Set the normal array (user normals)
        
        Parameters:
        normals : List['FloatVector']
            The normal array to set
        space : 'Space.Space'
            World space or Object space
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setNormals`
        """
        pass
    def setPoint(self, vertexId, pos, space="'preTransform'"):
        """
        Sets the position of specified vertex in the vertex list for this mesh.
        
        Parameters:
        vertexId : 'int'
            The object-relative (mesh-relative/global) index of the vertex to be changed
        pos : 'Point'
            The new value for the vertex
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setPoint`
        """
        pass
    def setPoints(self, vertexArray, space="'preTransform'"):
        """
        This method copies the points in the given point array to the vertices of this polygon.
        
        Parameters:
        vertexArray : List['FloatPoint']
            Storage for the vertex list
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setPoints`
        """
        pass
    def setSomeColors(self, colorIds, colorArray, colorSet='None'):
        """
        Sets the specified colors for this mesh. If the largest colorId in the array is larger than numColors() then the color list for this mesh will be grown to accommodate the new color values.
        
        Parameters:
        colorIds : List['int']
            The array of colorIds to set values for
        colorArray : List['Color']
            The array of color values to be set
        colorSet : 'unicode'
            Color set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.setSomeColors`
        """
        pass
    def setSomeUVs(self, uvIds, uArray, vArray, uvSet='None'):
        """
        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).
        
        Parameters:
        uvIds : List['int']
            The array of uvIds to set values for
        uArray : List['float']
            The array of u values to be set
        vArray : List['float']
            The array of v values to be set
        uvSet : 'unicode'
            UV set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.setSomeUVs`
        """
        pass
    def setUV(self, uvId, u, v, uvSet='None'):
        """
        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).
        
        Parameters:
        uvId : 'int'
            The element in the uv list to be set
        u : 'float'
            The new u value that is to be set
        v : 'float'
            The new v value that is to be set
        uvSet : 'unicode'
            UV set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.setUV`
        """
        pass
    def setUVs(self, uArray, vArray, uvSet='None'):
        """
        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.
        
        Parameters:
        uArray : List['float']
            The array of u values to be set
        vArray : List['float']
            The array of v values to be set
        uvSet : 'unicode'
            UV set to work with
        
        Derived from api method `maya.OpenMaya.MFnMesh.setUVs`
        """
        pass
    def setVertexColor(self, color, vertexIndex, modifier='None'):
        """
        Set color for this vertex. The color is set for the vertex-face in each face that the vertex belongs to.
        
        Parameters:
        color : 'Color'
            The color to set
        vertexIndex : 'int'
            The object-relative (mesh-relative/global) vertex index to set it for
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        
        Derived from api method `maya.OpenMaya.MFnMesh.setVertexColor`
        """
        pass
    def setVertexNormal(self, normalIn, vertexId, space="'preTransform'", modifier='None'):
        """
        Set Shared Normal for this vertex
        
        Parameters:
        normalIn : 'Vector'
            The normal to set
        vertexId : 'int'
            The object-relative (mesh-relative/global) vertex index to set it for
        space : 'Space.Space'
            World space or Object space
        
            values: 'transform', 'preTransform', 'object', 'world'
        modifier : 'MDGModifier'
            Since this method may modify the DG, if you wish to undo its effects, you need to keep track of what needs to be undone. If the modifier is non-null, and this MFnMesh refers to a shape, then it will add the command to be undone to the modifier. Use MDGModifier::undoIt to undo the effects of this method.
        
        Derived from api method `maya.OpenMaya.MSpace.setVertexNormal`
        """
        pass
    def 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.
        Derived from api method `maya.OpenMaya.MFnMesh.syncObject`
        """
        pass
    def unlockFaceVertexNormals(self, faceList, vertexList):
        """
        Unlock Normals for these face/vertex pairs
        
        Parameters:
        faceList : List['int']
            The faces to unlock normal in
        vertexList : List['int']
            The corresponding object-relative (global) vertex indices to unlock them for
        
        Derived from api method `maya.OpenMaya.MFnMesh.unlockFaceVertexNormals`
        """
        pass
    def unlockVertexNormals(self, vertexList):
        """
        Unlock Shared Normals for these vertices
        
        Parameters:
        vertexList : List['int']
            The vertices to unlock normals for
        
        Derived from api method `maya.OpenMaya.MFnMesh.unlockVertexNormals`
        """
        pass
    def updateSurface(self):
        """
        Signal that this polygonal mesh has changed and needs to redraw itself.
        Derived from api method `maya.OpenMaya.MFnMesh.updateSurface`
        """
        pass
    def worldArea(*args, **kwargs):
        """
        returns the surface area of the object's faces in world space as a float                  
        
        
        Derived from mel command `maya.cmds.polyEvaluate`
        """
        pass
    @classmethod
    def componentTypeFromName(self, assocName):
        """
        Get a component type from its string name.
        
        Parameters:
        assocName : 'unicode'
            String representing the component type
        
        
        Returns:
        'Fn.Type'
        
        Derived from api method `maya.OpenMaya.MFnMesh.componentTypeFromName`
        """
        pass
    @classmethod
    def componentTypeName(self, compType):
        """
        Get a string representing a particular component type
        
        Parameters:
        compType : 'Fn.Type'
            The type of component to fetch
        
            values: 'base', 'namedObject', 'model', 'dependencyNode', 'addDoubleLinear', 'affect', 'animCurve', 'animCurveTimeToAngular', 'animCurveTimeToDistance', 'animCurveTimeToTime', 'animCurveTimeToUnitless', 'animCurveUnitlessToAngular', 'animCurveUnitlessToDistance', 'animCurveUnitlessToTime', 'animCurveUnitlessToUnitless', 'resultCurve', 'resultCurveTimeToAngular', 'resultCurveTimeToDistance', 'resultCurveTimeToTime', 'resultCurveTimeToUnitless', 'angleBetween', 'audio', 'background', 'colorBackground', 'fileBackground', 'rampBackground', 'blend', 'blendTwoAttr', 'blendWeighted', 'blendDevice', 'blendColors', 'bump', 'bump3d', 'cameraView', 'chainToSpline', 'choice', 'condition', 'contrast', 'clampColor', 'create', 'alignCurve', 'alignSurface', 'attachCurve', 'attachSurface', 'avgCurves', 'avgSurfacePoints', 'avgNurbsSurfacePoints', 'bevel', 'birailSrf', 'DPbirailSrf', 'MPbirailSrf', 'SPbirailSrf', 'boundary', 'circle', 'closeCurve', 'closestPointOnSurface', 'closeSurface', 'curveFromSurface', 'curveFromSurfaceBnd', 'curveFromSurfaceCoS', 'curveFromSurfaceIso', 'curveInfo', 'detachCurve', 'detachSurface', 'extendCurve', 'extendSurface', 'extrude', 'FFblendSrf', 'FFfilletSrf', 'filletCurve', 'fitBspline', 'flow', 'hardenPointCurve', 'illustratorCurve', 'insertKnotCrv', 'insertKnotSrf', 'intersectSurface', 'nurbsTesselate', 'nurbsPlane', 'nurbsCube', 'offsetCos', 'offsetCurve', 'planarTrimSrf', 'pointOnCurveInfo', 'pointOnSurfaceInfo', 'primitive', 'projectCurve', 'projectTangent', 'RBFsurface', 'rebuildCurve', 'rebuildSurface', 'reverseCurve', 'reverseSurface', 'revolve', 'revolvedPrimitive', 'cone', 'renderCone', 'cylinder', 'sphere', 'skin', 'stitchSrf', 'subCurve', 'surfaceInfo', 'textCurves', 'trim', 'untrim', 'dagNode', 'proxy', 'underWorld', 'transform', 'aimConstraint', 'lookAt', 'geometryConstraint', 'geometryVarGroup', 'anyGeometryVarGroup', 'curveVarGroup', 'meshVarGroup', 'surfaceVarGroup', 'ikEffector', 'ikHandle', 'joint', 'manipulator3D', 'arrowManip', 'axesActionManip', 'ballProjectionManip', 'circleManip', 'screenAlignedCircleManip', 'circleSweepManip', 'concentricProjectionManip', 'cubicProjectionManip', 'cylindricalProjectionManip', 'discManip', 'freePointManip', 'centerManip', 'limitManip', 'enableManip', 'freePointTriadManip', 'propMoveTriadManip', 'towPointManip', 'polyCreateToolManip', 'polySplitToolManip', 'geometryOnLineManip', 'cameraPlaneManip', 'toggleOnLineManip', 'stateManip', 'isoparmManip', 'lineManip', 'manipContainer', 'averageCurveManip', 'barnDoorManip', 'bevelManip', 'blendManip', 'buttonManip', 'cameraManip', 'coiManip', 'cpManip', 'createCVManip', 'createEPManip', 'curveEdManip', 'curveSegmentManip', 'directionManip', 'dofManip', 'dropoffManip', 'extendCurveDistanceManip', 'extrudeManip', 'ikSplineManip', 'ikRPManip', 'jointClusterManip', 'lightManip', 'motionPathManip', 'offsetCosManip', 'offsetCurveManip', 'projectionManip', 'polyProjectionManip', 'projectionUVManip', 'projectionMultiManip', 'projectTangentManip', 'propModManip', 'quadPtOnLineManip', 'rbfSrfManip', 'reverseCurveManip', 'reverseCrvManip', 'reverseSurfaceManip', 'revolveManip', 'revolvedPrimitiveManip', 'spotManip', 'spotCylinderManip', 'triplanarProjectionManip', 'trsManip', 'dblTrsManip', 'pivotManip2D', 'manip2DContainer', 'polyMoveUVManip', 'polyMappingManip', 'polyModifierManip', 'polyMoveVertexManip', 'polyVertexNormalManip', 'texSmudgeUVManip', 'texLatticeDeformManip', 'texLattice', 'texSmoothManip', 'trsTransManip', 'trsInsertManip', 'trsXformManip', 'manipulator2D', 'translateManip2D', 'planarProjectionManip', 'pointOnCurveManip', 'towPointOnCurveManip', 'markerManip', 'pointOnLineManip', 'pointOnSurfaceManip', 'translateUVManip', 'rotateBoxManip', 'rotateManip', 'handleRotateManip', 'rotateLimitsManip', 'scaleLimitsManip', 'scaleManip', 'scalingBoxManip', 'scriptManip', 'sphericalProjectionManip', 'textureManip3D', 'toggleManip', 'translateBoxManip', 'translateLimitsManip', 'translateManip', 'trimManip', 'jointTranslateManip', 'manipulator', 'circlePointManip', 'dimensionManip', 'fixedLineManip', 'lightProjectionGeometry', 'lineArrowManip', 'pointManip', 'triadManip', 'normalConstraint', 'orientConstraint', 'pointConstraint', 'symmetryConstraint', 'parentConstraint', 'poleVectorConstraint', 'scaleConstraint', 'tangentConstraint', 'unknownTransform', 'world', 'shape', 'baseLattice', 'camera', 'cluster', 'softMod', 'collision', 'dummy', 'emitter', 'field', 'air', 'drag', 'gravity', 'newton', 'radial', 'turbulence', 'uniform', 'vortex', 'geometric', 'curve', 'nurbsCurve', 'nurbsCurveGeom', 'dimension', 'angle', 'annotation', 'distance', 'arcLength', 'radius', 'paramDimension', 'directedDisc', 'renderRect', 'envFogShape', 'lattice', 'latticeGeom', 'locator', 'dropoffLocator', 'marker', 'orientationMarker', 'positionMarker', 'orientationLocator', 'trimLocator', 'plane', 'sketchPlane', 'groundPlane', 'orthoGrid', 'sprite', 'surface', 'nurbsSurface', 'nurbsSurfaceGeom', 'mesh', 'meshGeom', 'renderSphere', 'flexor', 'clusterFlexor', 'guideLine', 'light', 'ambientLight', 'nonAmbientLight', 'areaLight', 'linearLight', 'nonExtendedLight', 'directionalLight', 'pointLight', 'spotLight', 'particle', 'polyToolFeedbackShape', 'rigidConstraint', 'rigid', 'spring', 'unknownDag', 'defaultLightList', 'deleteComponent', 'dispatchCompute', 'shadingEngine', 'displacementShader', 'distanceBetween', 'DOF', 'dummyConnectable', 'dynamicsController', 'geoConnectable', 'expression', 'extract', 'filter', 'filterClosestSample', 'filterEuler', 'filterSimplify', 'gammaCorrect', 'geometryFilt', 'bendLattice', 'blendShape', 'combinationShape', 'bulgeLattice', 'FFD', 'ffdDualBase', 'rigidDeform', 'sculpt', 'textureDeformer', 'textureDeformerHandle', 'tweak', 'weightGeometryFilt', 'clusterFilter', 'softModFilter', 'jointCluster', 'deltaMush', 'tension', 'proxWrap', 'wire', 'groupId', 'groupParts', 'guide', 'hsvToRgb', 'hyperGraphInfo', 'hyperLayout', 'hyperView', 'ikSolver', 'MCsolver', 'PASolver', 'SCsolver', 'RPsolver', 'splineSolver', 'ikSystem', 'imagePlane', 'lambert', 'reflect', 'blinn', 'phong', 'phongExplorer', 'layeredShader', 'lightInfo', 'leastSquares', 'lightFogMaterial', 'envFogMaterial', 'lightList', 'lightSource', 'luminance', 'makeGroup', 'material', 'diffuseMaterial', 'lambertMaterial', 'blinnMaterial', 'phongMaterial', 'lightSourceMaterial', 'materialInfo', 'matrixAdd', 'matrixHold', 'matrixMult', 'matrixPass', 'matrixWtAdd', 'midModifier', 'midModifierWithMatrix', 'polyBevel', 'polyTweak', 'polyAppend', 'polyChipOff', 'polyCloseBorder', 'polyCollapseEdge', 'polyCollapseF', 'polyCylProj', 'polyDelEdge', 'polyDelFacet', 'polyDelVertex', 'polyExtrudeFacet', 'polyMapCut', 'polyMapDel', 'polyMapSew', 'polyMergeEdge', 'polyMergeFacet', 'polyMoveEdge', 'polyMoveFacet', 'polyMoveFacetUV', 'polyMoveUV', 'polyMoveVertex', 'polyMoveVertexUV', 'polyNormal', 'polyPlanProj', 'polyProj', 'polyQuad', 'polySmooth', 'polySoftEdge', 'polySphProj', 'polySplit', 'polySubdEdge', 'polySubdFacet', 'polyTriangulate', 'polyCreator', 'polyPrimitive', 'polyCone', 'polyCube', 'polyCylinder', 'polyMesh', 'polySphere', 'polyTorus', 'polyCreateFacet', 'polyUnite', 'motionPath', 'pluginMotionPathNode', 'multilisterLight', 'multiplyDivide', 'oldGeometryConstraint', 'opticalFX', 'particleAgeMapper', 'particleCloud', 'particleColorMapper', 'particleIncandecenceMapper', 'particleTransparencyMapper', 'partition', 'place2dTexture', 'place3dTexture', 'pluginDependNode', 'pluginLocatorNode', 'plusMinusAverage', 'pointMatrixMult', 'polySeparate', 'postProcessList', 'projection', 'record', 'renderUtilityList', 'reverse', 'rgbToHsv', 'rigidSolver', 'set', 'textureBakeSet', 'vertexBakeSet', 'setRange', 'shaderGlow', 'shaderList', 'shadingMap', 'samplerInfo', 'shapeFragment', 'simpleVolumeShader', 'sl60', 'snapshot', 'storyBoard', 'summaryObject', 'super', 'control', 'surfaceLuminance', 'surfaceShader', 'textureList', 'textureEnv', 'envBall', 'envCube', 'envChrome', 'envSky', 'envSphere', 'texture2d', 'bulge', 'checker', 'cloth', 'fileTexture', 'fractal', 'grid', 'mountain', 'ramp', 'stencil', 'water', 'texture3d', 'brownian', 'cloud', 'crater', 'granite', 'leather', 'marble', 'rock', 'snow', 'solidFractal', 'stucco', 'txSl', 'wood', 'time', 'timeToUnitConversion', 'renderSetup', 'renderGlobals', 'renderGlobalsList', 'renderQuality', 'resolution', 'hardwareRenderGlobals', 'arrayMapper', 'unitConversion', 'unitToTimeConversion', 'useBackground', 'unknown', 'vectorProduct', 'volumeShader', 'component', 'curveCVComponent', 'curveEPComponent', 'curveKnotComponent', 'curveParamComponent', 'isoparmComponent', 'pivotComponent', 'surfaceCVComponent', 'surfaceEPComponent', 'surfaceKnotComponent', 'edgeComponent', 'latticeComponent', 'surfaceRangeComponent', 'decayRegionCapComponent', 'decayRegionComponent', 'meshComponent', 'meshEdgeComponent', 'meshPolygonComponent', 'meshFrEdgeComponent', 'meshVertComponent', 'meshFaceVertComponent', 'orientationComponent', 'subVertexComponent', 'multiSubVertexComponent', 'setGroupComponent', 'dynParticleSetComponent', 'selectionItem', 'dagSelectionItem', 'nonDagSelectionItem', 'itemList', 'attribute', 'numericAttribute', 'doubleAngleAttribute', 'floatAngleAttribute', 'doubleLinearAttribute', 'floatLinearAttribute', 'timeAttribute', 'enumAttribute', 'unitAttribute', 'typedAttribute', 'compoundAttribute', 'genericAttribute', 'lightDataAttribute', 'matrixAttribute', 'floatMatrixAttribute', 'messageAttribute', 'plugin', 'data', 'componentListData', 'doubleArrayData', 'intArrayData', 'latticeData', 'matrixData', 'meshData', 'nurbsSurfaceData', 'nurbsCurveData', 'numericData', 'data2Double', 'data2Float', 'data2Long', 'data2Short', 'data3Double', 'data3Float', 'data3Int', 'data3Short', 'pluginData', 'pointArrayData', 'matrixArrayData', 'sphereData', 'stringData', 'stringArrayData', 'vectorArrayData', 'selectionList', 'transformGeometry', 'commEdgePtManip', 'commEdgeOperManip', 'commEdgeSegmentManip', 'commCornerManip', 'commCornerOperManip', 'pluginDeformerNode', 'torus', 'polyBoolOp', 'singleShadingSwitch', 'doubleShadingSwitch', 'tripleShadingSwitch', 'nurbsSquare', 'anisotropy', 'nonLinear', 'deformFunc', 'deformBend', 'deformTwist', 'deformSquash', 'deformFlare', 'deformSine', 'deformWave', 'deformBendManip', 'deformTwistManip', 'deformSquashManip', 'deformFlareManip', 'deformSineManip', 'deformWaveManip', 'softModManip', 'distanceManip', 'script', 'curveFromMeshEdge', 'curveCurveIntersect', 'nurbsCircular3PtArc', 'nurbsCircular2PtArc', 'offsetSurface', 'roundConstantRadius', 'roundRadiusManip', 'roundRadiusCrvManip', 'roundConstantRadiusManip', 'threePointArcManip', 'twoPointArcManip', 'textButtonManip', 'offsetSurfaceManip', 'imageData', 'imageLoad', 'imageSave', 'imageNetSrc', 'imageNetDest', 'imageRender', 'imageAdd', 'imageDiff', 'imageMultiply', 'imageOver', 'imageUnder', 'imageColorCorrect', 'imageBlur', 'imageFilter', 'imageDepth', 'imageDisplay', 'imageView', 'imageMotionBlur', 'viewColorManager', 'matrixFloatData', 'skinShader', 'componentManip', 'selectionListData', 'objectFilter', 'objectMultiFilter', 'objectNameFilter', 'objectTypeFilter', 'objectAttrFilter', 'objectRenderFilter', 'objectScriptFilter', 'selectionListOperator', 'subdiv', 'polyToSubdiv', 'skinClusterFilter', 'keyingGroup', 'character', 'characterOffset', 'dagPose', 'stitchAsNurbsShell', 'explodeNurbsShell', 'nurbsBoolean', 'stitchSrfManip', 'forceUpdateManip', 'pluginManipContainer', 'polySewEdge', 'polyMergeVert', 'polySmoothFacet', 'smoothCurve', 'globalStitch', 'subdivCVComponent', 'subdivEdgeComponent', 'subdivFaceComponent', 'UVManip2D', 'translateUVManip2D', 'rotateUVManip2D', 'scaleUVManip2D', 'polyTweakUV', 'moveUVShellManip2D', 'pluginShape', 'geometryData', 'singleIndexedComponent', 'doubleIndexedComponent', 'tripleIndexedComponent', 'extendSurfaceDistanceManip', 'squareSrf', 'squareSrfManip', 'subdivToPoly', 'dynBase', 'dynEmitterManip', 'dynFieldsManip', 'dynBaseFieldManip', 'dynAirManip', 'dynNewtonManip', 'dynTurbulenceManip', 'dynSpreadManip', 'dynAttenuationManip', 'dynArrayAttrsData', 'pluginFieldNode', 'pluginEmitterNode', 'pluginSpringNode', 'displayLayer', 'displayLayerManager', 'polyColorPerVertex', 'createColorSet', 'deleteColorSet', 'copyColorSet', 'blendColorSet', 'polyColorMod', 'polyColorDel', 'characterMappingData', 'dynSweptGeometryData', 'wrapFilter', 'meshVtxFaceComponent', 'binaryData', 'attribute2Double', 'attribute2Float', 'attribute2Short', 'attribute2Long', 'attribute3Double', 'attribute3Float', 'attribute3Short', 'attribute3Int', 'reference', 'blindData', 'blindDataTemplate', 'polyBlindData', 'polyNormalPerVertex', 'nurbsToSubdiv', 'pluginIkSolver', 'instancer', 'moveVertexManip', 'stroke', 'brush', 'strokeGlobals', 'pluginGeometryData', 'lightLink', 'dynGlobals', 'polyReduce', 'lodThresholds', 'chooser', 'lodGroup', 'multDoubleLinear', 'fourByFourMatrix', 'towPointOnSurfaceManip', 'surfaceEdManip', 'surfaceFaceComponent', 'clipScheduler', 'clipLibrary', 'subSurface', 'smoothTangentSrf', 'renderPass', 'renderPassSet', 'renderLayer', 'renderLayerManager', 'passContributionMap', 'precompExport', 'renderTarget', 'renderedImageSource', 'imageSource', 'polyFlipEdge', 'polyExtrudeEdge', 'animBlend', 'animBlendInOut', 'polyAppendVertex', 'uvChooser', 'subdivCompId', 'volumeAxis', 'deleteUVSet', 'subdHierBlind', 'subdBlindData', 'characterMap', 'layeredTexture', 'subdivCollapse', 'particleSamplerInfo', 'copyUVSet', 'createUVSet', 'clip', 'polySplitVert', 'subdivData', 'subdivGeom', 'UInt64ArrayData', 'int64ArrayData', 'polySplitEdge', 'subdivReverseFaces', 'meshMapComponent', 'sectionManip', 'xsectionSubdivEdit', 'subdivToNurbs', 'editCurve', 'editCurveManip', 'crossSectionManager', 'createSectionManip', 'crossSectionEditManip', 'dropOffFunction', 'subdBoolean', 'subdModifyEdge', 'modifyEdgeCrvManip', 'modifyEdgeManip', 'scalePointManip', 'transformBoxManip', 'symmetryLocator', 'symmetryMapVector', 'symmetryMapCurve', 'curveFromSubdivEdge', 'createBPManip', 'modifyEdgeBaseManip', 'subdExtrudeFace', 'subdivSurfaceVarGroup', 'sfRevolveManip', 'curveFromSubdivFace', 'unused1', 'unused2', 'unused3', 'unused4', 'unused5', 'unused6', 'polyTransfer', 'polyAverageVertex', 'polyAutoProj', 'polyLayoutUV', 'polyMapSewMove', 'subdModifier', 'subdMoveVertex', 'subdMoveEdge', 'subdMoveFace', 'subdDelFace', 'snapshotShape', 'subdivMapComponent', 'jiggleDeformer', 'globalCacheControls', 'diskCache', 'subdCloseBorder', 'subdMergeVert', 'boxData', 'box', 'renderBox', 'subdSplitFace', 'volumeFog', 'subdTweakUV', 'subdMapCut', 'subdLayoutUV', 'subdMapSewMove', 'ocean', 'volumeNoise', 'subdAutoProj', 'subdSubdivideFace', 'noise', 'attribute4Double', 'data4Double', 'subdPlanProj', 'subdTweak', 'subdProjectionManip', 'subdMappingManip', 'hardwareReflectionMap', 'polyNormalizeUV', 'polyFlipUV', 'hwShaderNode', 'pluginHardwareShader', 'pluginHwShaderNode', 'subdAddTopology', 'subdCleanTopology', 'implicitCone', 'implicitSphere', 'rampShader', 'volumeLight', 'oceanShader', 'bevelPlus', 'styleCurve', 'polyCut', 'polyPoke', 'polyWedgeFace', 'polyCutManipContainer', 'polyCutManip', 'polyMirrorManipContainer', 'polyPokeManip', 'fluidTexture3D', 'fluidTexture2D', 'polyMergeUV', 'polyStraightenUVBorder', 'alignManip', 'pluginTransformNode', 'fluid', 'fluidGeom', 'fluidData', 'smear', 'stringShadingSwitch', 'studioClearCoat', 'fluidEmitter', 'heightField', 'geoConnector', 'snapshotPath', 'pluginObjectSet', 'quadShadingSwitch', 'polyExtrudeVertex', 'pairBlend', 'textManip', 'viewManip', 'xformManip', 'mute', 'constraint', 'trimWithBoundaries', 'curveFromMeshCoM', 'follicle', 'hairSystem', 'remapValue', 'remapColor', 'remapHsv', 'hairConstraint', 'timeFunction', 'mentalRayTexture', 'objectBinFilter', 'polySmoothProxy', 'pfxGeometry', 'pfxHair', 'hairTubeShader', 'psdFileTexture', 'keyframeDelta', 'keyframeDeltaMove', 'keyframeDeltaScale', 'keyframeDeltaAddRemove', 'keyframeDeltaBlockAddRemove', 'keyframeDeltaInfType', 'keyframeDeltaTangent', 'keyframeDeltaWeighted', 'keyframeDeltaBreakdown', 'polyMirror', 'polyCreaseEdge', 'polyPinUV', 'hikEffector', 'hikIKEffector', 'hikFKJoint', 'hikSolver', 'hikHandle', 'proxyManager', 'polyAutoProjManip', 'polyPrism', 'polyPyramid', 'polySplitRing', 'pfxToon', 'toonLineAttributes', 'polyDuplicateEdge', 'facade', 'materialFacade', 'envFacade', 'AISEnvFacade', 'lineModifier', 'polyArrow', 'polyPrimitiveMisc', 'polyPlatonicSolid', 'polyPipe', 'hikFloorContactMarker', 'hikGroundPlane', 'polyComponentData', 'polyHelix', 'cacheFile', 'historySwitch', 'closestPointOnMesh', 'pinToGeometryUV', 'pinToGeometryProx', 'transferAttributes', 'dynamicConstraint', 'NComponent', 'polyBridgeEdge', 'cacheableNode', 'nucleus', 'NBase', 'cacheBase', 'cacheBlend', 'cacheTrack', 'keyframeRegionManip', 'curveNormalizerAngle', 'curveNormalizerLinear', 'hyperLayoutDG', 'pluginImagePlaneNode', 'NCloth', 'NParticle', 'NRigid', 'pluginParticleAttributeMapperNode', 'cameraSet', 'pluginCameraSet', 'container', 'floatVectorArrayData', 'NObjectData', 'NObject', 'pluginConstraintNode', 'asset', 'polyEdgeToCurve', 'animLayer', 'blendNodeBase', 'blendNodeBoolean', 'blendNodeDouble', 'blendNodeDoubleAngle', 'blendNodeDoubleLinear', 'blendNodeEnum', 'blendNodeFloat', 'blendNodeFloatAngle', 'blendNodeFloatLinear', 'blendNodeInt16', 'blendNodeInt32', 'blendNodeAdditiveScale', 'blendNodeAdditiveRotation', 'pluginManipulatorNode', 'NIdData', 'NId', 'floatArrayData', 'membrane', 'mergeVertsToolManip', 'uint64SingleIndexedComponent', 'polyToolFeedbackManip', 'polySelectEditFeedbackManip', 'writeToFrameBuffer', 'writeToColorBuffer', 'writeToVectorBuffer', 'writeToDepthBuffer', 'writeToLabelBuffer', 'stereoCameraMaster', 'sequenceManager', 'sequencer', 'shot', 'blendNodeTime', 'createBezierManip', 'bezierCurve', 'bezierCurveData', 'nurbsCurveToBezier', 'bezierCurveToNurbs', 'polySpinEdge', 'polyHoleFace', 'pointOnPolyConstraint', 'polyConnectComponents', 'skinBinding', 'volumeBindManip', 'vertexWeightSet', 'nearestPointOnCurve', 'colorProfile', 'adskMaterial', 'containerBase', 'dagContainer', 'polyUVRectangle', 'hardwareRenderingGlobals', 'polyProjectCurve', 'renderingList', 'polyExtrudeManip', 'polyExtrudeManipContainer', 'threadedDevice', 'clientDevice', 'pluginClientDevice', 'pluginThreadedDevice', 'timeWarp', 'assembly', 'clipGhostShape', 'clipToGhostData', 'mandelbrot', 'mandelbrot3D', 'greasePlane', 'greasePlaneRenderShape', 'greasePencilSequence', 'editMetadata', 'creaseSet', 'polyEditEdgeFlow', 'fosterParent', 'snapUVManip2D', 'toolContext', 'NLE', 'shrinkWrapFilter', 'editsManager', 'polyBevel2', 'polyCBoolOp', 'geomBind', 'colorMgtGlobals', 'polyBevel3', 'timeEditorClipBase', 'timeEditorClipEvaluator', 'timeEditorClip', 'timeEditor', 'timeEditorTracks', 'timeEditorInterpolator', 'timeEditorAnimSource', 'caddyManipBase', 'polyCaddyManip', 'polyModifierManipContainer', 'polyRemesh', 'polyContourProj', 'contourProjectionManip', 'nodeGraphEditorInfo', 'nodeGraphEditorBookmarks', 'nodeGraphEditorBookmarkInfo', 'pluginSkinCluster', 'pluginGeometryFilter', 'pluginBlendShape', 'polyPassThru', 'trackInfoManager', 'polyClean', 'shapeEditorManager', 'oceanDeformer', 'poseInterpolatorManager', 'controllerTag', 'reForm', 'customEvaluatorClusterNode', 'polyCircularize', 'arubaTesselate', 'reorderUVSet'
        
        
        Returns:
        'unicode'
        
        Derived from api method `maya.OpenMaya.MFn.componentTypeName`
        """
        pass
    @classmethod
    def polyTriangulate(self, pointsAndHoles, pointsCount, outerPointsCount, holesCount, considerNormal, normals):
        """
        Triangulates a polygon. The polygon consists of 2D positions with optional 3D normals and holes. These 2D positions can be in any coordinate system. 3D positions can be projected to a 2D plane by its face normal. 3D normals are references to help triangulation. This function can work without normals but normals can improve the quality. This function works with pointers and is more efficient than the other variant.
        
        Parameters:
        pointsAndHoles : 'float'
            Array of 2D positions and hole description. The array contains 2D positions (x,y) followed by the hole offsets. For example, if pointsAndHoles = [x1, y1, x2, y2, ..., x9, y9, o1, o1, o2, o2], then this means that (x1, y1) ~ (x9, y9) are positions, o1 is the offset for the first loop and o2 is the offset for the second loop.
        pointsCount : 'int'
            The number of 2D positions in pointsAndHoles
        outerPointsCount : 'int'
            The number of outer (non-hole) 2D positions in pointsAndHoles
        holesCount : 'int'
            The number of holes in pointsAndHoles
        considerNormal : 'bool'
            If true then normals are considered during triangulation
        normals : 'float'
            Array of 3D normals. If considerNormal is false, this array can be nullptr. If considerNormal is true, then there must be one normal per point.
        
        
        Returns:
        Tuple['int', 'int']
        
        Derived from api method `maya.OpenMaya.MFnMesh.polyTriangulate`
        """
        pass
    BoolOperation = {}
    
    
    MColorRepresentation = {}
    
    
    SplitPlacement = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class Subdiv(SurfaceShape):
    def cleanTopology(self): pass
    def collapse(self, level, makeNewNodeInvisible):
        """
        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.
        
        Parameters:
        level : 'int'
            the number of levels of the hierarchy to collapse
        makeNewNodeInvisible : 'bool'
            sets the invisible attribute of the new node
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnSubd.collapse`
        """
        pass
    def convertToNurbs(self):
        """
        Converts this surface to a set of nurbs surfaces.
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnSubd.convertToNurbs`
        """
        pass
    def copy(self, source, parentOrOwner="'MObject::kNullObj'"):
        """
        This method creates a copy of a given source subdivision surface. After the copy this function set will operate on the new subdivision surface.
        
        Parameters:
        source : 'PyNode'
            the subdivision surface to be copied
        parentOrOwner : 'PyNode'
            the DAG parent or kSubdivData the new subdivision surface will belong to
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnSubd.copy`
        """
        pass
    def creasesClearAll(self):
        """
        Clear all crease information from this surface. No vertices or edges will be creased after this function completes.
        Derived from api method `maya.OpenMaya.MFnSubd.creasesClearAll`
        """
        pass
    def createBaseMesh(self, reverseNormal, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, parentOrOwner="'MObject::kNullObj'"):
        """
        Creates a new subdivision surface given an array of vertices and connection information and sets this function set to operate on the new surface.
        
        Parameters:
        reverseNormal : 'bool'
            Not currently used
        numVertices : 'int'
            number of vertices
        numPolygons : 'int'
            number of polygons
        vertexArray : List['Point']
            point (vertex) array
        polygonCounts : List['int']
            array of vertex counts for each polygon
        polygonConnects : List['int']
            array of vertex connections for each polygon
        parentOrOwner : 'PyNode'
            parent of the polygon that will be created
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnSubd.createBaseMesh`
        """
        pass
    def editsPending(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.editsPending`
        """
        pass
    def editsUpdateAll(self):
        """
        If there are pending edits, this function will update the surface so that there are no pending edits.
        Derived from api method `maya.OpenMaya.MFnSubd.editsUpdateAll`
        """
        pass
    def getCurrentLevel(self, **kwargs):
        """
        When queried, this flag returns an integer representing the level of the currently selected subdiv surface component(s). Returns -1, if there are more than one level of CVs are selected, (even if they are from different objects) Returns -2, if there are no input subdiv CVs to process.                              
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getCurrentSubdLevel(self, **kwargs):
        """
        When queried, this flag returns an integer representing the level of the currently selected subdiv surface, regardless of whether components are selected or not. Returns -2, if there are no input subdiv CVs to process.                                 
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getDeepestLevel(self, **kwargs):
        """
        When queried, this flag returns an integer representing the deepest level to which the queried subdiv surface has been subdivided.                                 
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getDisplayLoad(self, **kwargs):
        """
        When queried, this flag prints the display load of selected subdiv                                 
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getEdgeStats(self, **kwargs):
        """
        When queried, this flag prints stats on the current subd.                                  
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getEdges(self, **kwargs): pass
    def getFaceStats(self, **kwargs):
        """
        When queried, this flag prints stats on the current subd.                                  
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getMaxPossibleLevel(self, **kwargs):
        """
        When queried, this flag returns an integer representing the maximum possible level to which the queried subdiv surface can been subdivided.                                
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getProxyMode(self, **kwargs):
        """
        When queried, this flag returns an integer representing whether or not the subdivision surface is in polygon proxymode. Proxymode allows the base mesh of a subdivision surface without construction history to be edited using the polygonal editing tools. Returns 1, if the subdivision surface is in polygon proxymode. Returns 0, if the surface is not currently in proxymode, but could be put into proxymode since it has no construction history.  (This state is also known as standardmode.) Returns 2, if the surface is not in proxymode and cannot be put into proxy mode, as it has construction history.                                   
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getSharpenedEdges(self, **kwargs): pass
    def getSharpenedVerts(self, **kwargs): pass
    def getSmallOffsets(self, **kwargs):
        """
        When queried, this flag prints the number of subdiv vertices in the hierarchy that have a small enough offset so that the vertex is not required                                   Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    def getTweakedVerts(self, **kwargs): pass
    def levelFullySubdivideTo(self, level):
        """
        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.
        
        Parameters:
        level : 'int'
            The level to which to fully subdivide
        
        Derived from api method `maya.OpenMaya.MFnSubd.levelFullySubdivideTo`
        """
        pass
    def levelMaxAllowed(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.levelMaxAllowed`
        """
        pass
    def levelMaxCurrent(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.levelMaxCurrent`
        """
        pass
    def numEdges(self, level='0'):
        """
        Returns the number of edges at a level.
        
        Parameters:
        level : 'int'
            The level where we're counting the edges
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.edgeCount`
        """
        pass
    def numFaces(self, level='0'):
        """
        Returns the number of polygons currently existing at the specified level of the hierarchy.
        
        Parameters:
        level : 'int'
            Level at which we're counting
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.polygonCount`
        """
        pass
    def numVertices(self, level='0'):
        """
        Returns the finest vertex count at a particular level. These are the vertices that are currently instantiated.
        
        Parameters:
        level : 'int'
            The level we are interested in
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.vertexCount`
        """
        pass
    def polygonCountMaxWithGivenBaseMesh(self, level='1'):
        """
        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.
        
        Parameters:
        level : 'int'
            The level where you would be counting
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.polygonCountMaxWithGivenBaseMesh`
        """
        pass
    def tesselate(self, uniform, depth, sample, parentOrOwner="'MObject::kNullObj'"):
        """
        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.
        
        Parameters:
        uniform : 'bool'
            Use uniform tesselation if this is set.
        depth : 'int'
            Used in the uniform tesselation: how deep do we go
        sample : 'int'
            In both tesselation cases, once we decide which level to tesselate at, how many times do we sample.
        parentOrOwner : 'PyNode'
            the DAG parent or kMeshData the new Mesh will belong to
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnSubd.tesselate`
        """
        pass
    def tessellateViaNurbs(self, parentOrOwner="'MObject::kNullObj'"):
        """
        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.
        
        Parameters:
        parentOrOwner : 'PyNode'
            the DAG parent or kMeshData the new Mesh will belong to
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnSubd.tessellateViaNurbs`
        """
        pass
    def 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.
        Derived from api method `maya.OpenMaya.MFnSubd.updateAllEditsAndCreases`
        """
        pass
    def updateSubdSurface(self):
        """
        Signal that this subdivision surface has changed and needs to redraw itself.
        Derived from api method `maya.OpenMaya.MFnSubd.updateSubdSurface`
        """
        pass
    def vertexBaseMeshAdd(self, x, y, z):
        """
        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.
        
        Parameters:
        x : 'float'
            X location of the vertex
        y : 'float'
            Y location of the vertex
        z : 'float'
            Z location of the vertex
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnSubd.vertexBaseMeshAdd`
        """
        pass
    def vertexBaseMeshAddWithIndex(self, x, y, z, index):
        """
        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.
        
        Parameters:
        x : 'float'
            X location of the vertex
        y : 'float'
            Y location of the vertex
        z : 'float'
            Z location of the vertex
        index : 'int'
            The index the vertex is to take
        
        Derived from api method `maya.OpenMaya.MFnSubd.vertexBaseMeshAddWithIndex`
        """
        pass
    def vertexBaseMeshGet(self, space="'preTransform'"):
        """
        Return all base mesh vertices in the array using their indices (not the 64-bit names).
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        List['Point']
        
        Derived from api method `maya.OpenMaya.MSpace.vertexBaseMeshGet`
        """
        pass
    def vertexBaseMeshSet(self, space="'preTransform'"):
        """
        Set the positions for the base mesh vertices using the 0, 1,... indexing instead of the 64-bit vertex names.
        
        Parameters:
        space : 'Space.Space'
            Specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        List['Point']
        
        Derived from api method `maya.OpenMaya.MSpace.vertexBaseMeshSet`
        """
        pass
    def vertexEditsClearAllNonBase(self):
        """
        Find all vertices with edits and remove those edits, setting them back to their original position.
        Derived from api method `maya.OpenMaya.MFnSubd.vertexEditsClearAllNonBase`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Provides useful information about the selected subdiv or components, such as the
        deepest subdivided level, the children or parents of the currently selected
        components, etc.            In query mode, return type is based on queried flag.
        
        Flags:
        - currentLevel : cl              (bool)          [create,query]
            When queried, this flag returns an integer representing the level of the
            currently selected subdiv surface component(s). Returns -1, if there are more
            than one level of CVs are selected, (even if they are from different objects)
            Returns -2, if there are no input subdiv CVs to process.
        
        - currentSubdLevel : csl         (bool)          [create,query]
            When queried, this flag returns an integer representing the level of the
            currently selected subdiv surface, regardless of whether components are selected
            or not. Returns -2, if there are no input subdiv CVs to process.
        
        - deepestLevel : dl              (int)           [create,query]
            When queried, this flag returns an integer representing the deepest level to
            which the queried subdiv surface has been subdivided.
        
        - displayLoad : dsl              (bool)          [create,query]
            When queried, this flag prints the display load of selected subdiv
        
        - edgeStats : est                (bool)          [create,query]
            When queried, this flag prints stats on the current subd.
        
        - faceStats : fst                (bool)          [create,query]
            When queried, this flag prints stats on the current subd.
        
        - maxPossibleLevel : mpl         (int)           [create,query]
            When queried, this flag returns an integer representing the maximum possible
            level to which the queried subdiv surface can been subdivided.
        
        - proxyMode : pm                 (int)           [create,query]
            When queried, this flag returns an integer representing whether or not the
            subdivision surface is in polygon proxymode. Proxymode allows the base mesh of a
            subdivision surface without construction history to be edited using the
            polygonal editing tools. Returns 1, if the subdivision surface is in polygon
            proxymode. Returns 0, if the surface is not currently in proxymode, but could be
            put into proxymode since it has no construction history.  (This state is also
            known as standardmode.) Returns 2, if the surface is not in proxymode and cannot
            be put into proxy mode, as it has construction history.
        
        - smallOffsets : so              (bool)          [create,query]
            When queried, this flag prints the number of subdiv vertices in the hierarchy
            that have a small enough offset so that the vertex is not required
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.subdiv`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NCloth(NBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSkyDomeLight(SphereLocator):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class NRigid(NBase):
    __melnode__ = []
    
    
    __readonly__ = {}


class HeightField(SurfaceShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class AiSky(SphereLocator):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class MotionTrailShape(SnapshotShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class NurbsSurface(SurfaceShape):
    def area(self, tolerance='0.001'):
        """
        Calculates the surface area of this nurbs surface. A value of 0.0 will be returned if the area cannot be determined successfully.
        
        Parameters:
        tolerance : 'float'
            tolerance value to be used for computations
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.area`
        """
        pass
    def assignUV(self, patchId, cornerIndex, uvId):
        """
        Maps a texture coordinate to a the specified corner of a patch.
        
        Parameters:
        patchId : 'int'
            The patch to map to
        cornerIndex : 'int'
            The corner of the patch to map to
        uvId : 'int'
            The uv entry from the uv list that will be mapped
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.assignUV`
        """
        pass
    def assignUVs(self, uvCounts, uvIds):
        """
        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.
        
        Parameters:
        uvCounts : List['int']
            The uv counts for each patch in the surface
        uvIds : List['int']
            The uv indices to be mapped to each patch-corner
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.assignUVs`
        """
        pass
    def boundaryType(self, region, boundary):
        """
        Returns the type of the specified boundary. The surface must be a trimmed surface.
        
        Parameters:
        region : 'int'
            the region to examine
        boundary : 'int'
            the boundary to examine
        
        
        Returns:
        'NurbsSurface.BoundaryType'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.boundaryType`
        """
        pass
    def clearUVs(self):
        """
        This method clears out all texture coordinates for the nurbsSurface, and leaves behind an empty UVset.
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.clearUVs`
        """
        pass
    def closestPoint(self, toThisPoint, ignoreTrimBoundaries='False', tolerance='0.001', space="'preTransform'"):
        """
        Return the closest point on this surface to the given point.
        
        Parameters:
        toThisPoint : 'Point'
            Point to be compared.
        ignoreTrimBoundaries : 'bool'
            If this is true and the surface is trimmed, look for the point on the entire, untrimmed surface ignoring any trim curves.
        tolerance : 'float'
            Tolerance value to be used for computations.
        space : 'Space.Space'
            Coordinate space in which perform this operation,
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        Tuple['Point', 'float', 'float']
        
        Derived from api method `maya.OpenMaya.MSpace.closestPoint`
        """
        pass
    def copy(self, source, parentOrOwner="'MObject::kNullObj'"):
        """
        This method creates a copy of a nurbs surface.
        
        Parameters:
        source : 'PyNode'
            the surface to be copied
        parentOrOwner : 'PyNode'
            the DAG parent or kNurbsSurfaceData the new surface will belong to
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.copy`
        """
        pass
    def cvsInU(self, startIndex, endIndex, rowIndex):
        """
        Returns a component for the specified CVs.
        
        Parameters:
        startIndex : 'int'
            start CV index in U
        endIndex : 'int'
            end CV index in U
        rowIndex : 'int'
            row index
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.cvsInU`
        """
        pass
    def cvsInV(self, startIndex, endIndex, rowIndex):
        """
        Returns a component for the specified CVs on the given V direction.
        
        Parameters:
        startIndex : 'int'
            start CV index in V
        endIndex : 'int'
            end CV index in V
        rowIndex : 'int'
            row index
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.cvsInV`
        """
        pass
    def degreeU(self):
        """
        Returns the degree of the surface in U (1 - 3).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.degreeU`
        """
        pass
    def degreeV(self):
        """
        Returns the degree of the surface in V (1 - 3).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.degreeV`
        """
        pass
    def distanceToPoint(self, pt, space="'preTransform'"):
        """
        Returns the distance from the given point to the closest point on the surface.
        
        Parameters:
        pt : 'Point'
            Point to calculate distance from
        space : 'Space.Space'
            Coordinate space for which to perform operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MSpace.distanceToPoint`
        """
        pass
    def edge(self, region, boundary, edge, paramEdge='False'):
        """
        Return the specified edge of a trim boundary.
        
        Parameters:
        region : 'int'
            the trimmed region containing the edge
        boundary : 'int'
            the boundary to examine
        edge : 'int'
            the boundary edge to examine
        paramEdge : 'bool'
            if true then 2D param edges are returned, otherwise a 3D edge is returned.
        
        
        Returns:
        List['PyNode']
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.edge`
        """
        pass
    def formInU(self):
        """
        Return the form of this surface in U. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.
        
        Returns:
        'NurbsSurface.Form'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.formInU`
        """
        pass
    def formInV(self):
        """
        Return the form of this surface in V. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.
        
        Returns:
        'NurbsSurface.Form'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.formInV`
        """
        pass
    def getAssignedUVs(self):
        """
        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.
        
        Returns:
        Tuple[List['int'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getAssignedUVs`
        """
        pass
    def getCV(self, indexU, indexV, space="'preTransform'"):
        """
        Get the location of the specified CV.
        
        Parameters:
        indexU : 'int'
            U index of CV
        indexV : 'int'
            V index of CV
        space : 'Space.Space'
            coordinate space for the CV
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.getCV`
        """
        pass
    def getCVs(self, space="'preTransform'"):
        """
        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".
        
        Parameters:
        space : 'Space.Space'
            specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        List['Point']
        
        Derived from api method `maya.OpenMaya.MSpace.getCVs`
        """
        pass
    def getConnectedShaders(self, instanceNumber):
        """
        Returns all the shaders (sets) connected to the specified instance of this surface, as well as an array of patch/shader assignments. The indices array will hold, for each patch in the surface, an index into the shaders array. If a patch does not have a shader assigned to it, the value of the index will be -1.
        
        Parameters:
        instanceNumber : 'int'
            The instance number of the surface to query
        
        
        Returns:
        Tuple[List['PyNode'], List['int']]
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getConnectedShaders`
        """
        pass
    def getDataObject(self):
        """
        Returns an MObject if the class has been constructed with an MFn::kNurbsSurfaceData entity, otherwise MObject::kNullObj is returned.
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getDataObject`
        """
        pass
    def getDerivativesAtParm(self, paramInU, paramInV, space):
        """
        Evaluate the surface at the given (u,v) coordinate returning position, first derivatives and optionally second derivative information. The returned derivative vectors are not normalized. If either dUU, dVV, or dUV is set to nullptr, the second derivatives will not be computed and execution time wil be faster.
        
        Parameters:
        paramInU : 'float'
            U parameter value to evaluate
        paramInV : 'float'
            V parameter value to evaluate
        space : 'Space.Space'
            Coordinate space for the returned vectors
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        Tuple['Point', 'Vector', 'Vector', 'Vector', 'Vector', 'Vector']
        
        Derived from api method `maya.OpenMaya.MSpace.getDerivativesAtParm`
        """
        pass
    def getKnotDomain(self):
        """
        Returns the maximum and minimum U and V paramter values for this surface.
        
        Returns:
        Tuple['float', 'float', 'float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getKnotDomain`
        """
        pass
    def getKnotInU(self, index):
        """
        Retrieve the given knot value from this surface at the specified U index. U knots are indexed from 0 to numKnotsInU()-1.
        
        Parameters:
        index : 'int'
            The U index of the knot value to get
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.knotInU`
        """
        pass
    def getKnotInV(self, index):
        """
        Retrieve the given knot value from this surface at the specified V index. V knots are indexed from 0 to numKnotsInV()-1.
        
        Parameters:
        index : 'int'
            The V index of the knot value to get
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.knotInV`
        """
        pass
    def getKnotsInU(self):
        """
        Get the knots along the U direction for this surface.
        
        Returns:
        List['float']
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getKnotsInU`
        """
        pass
    def getKnotsInV(self):
        """
        Get the knots along the V direction for this surface.
        
        Returns:
        List['float']
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getKnotsInV`
        """
        pass
    def getParamAtPoint(*args, **kwargs):
        """
        The function '{objName}' has been deprecated by maya and may become unavailable in future maya versions
        """
        pass
    def getPatchUV(self, patchId, cornerIndex):
        """
        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.
        
        Parameters:
        patchId : 'int'
            The patch to examine
        cornerIndex : 'int'
            The patch-relative corner to examine
        
        
        Returns:
        Tuple['float', 'float']
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getPatchUV`
        """
        pass
    def getPatchUVid(self, patchId, cornerIndex):
        """
        Get the id of the specified texture coordinate for a corner in a patch.
        
        Parameters:
        patchId : 'int'
            The patch to examine
        cornerIndex : 'int'
            The patch-relative corner to examine (local index)
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getPatchUVid`
        """
        pass
    def getPatchUVs(self, patchId):
        """
        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.
        
        Parameters:
        patchId : 'int'
            The patch to examine
        
        
        Returns:
        Tuple[List['float'], List['float']]
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.getPatchUVs`
        """
        pass
    def getPointAtParam(self, paramU, paramV, space="'preTransform'"):
        """
        Finds the point corresponding to the given parameter value on the surface.
        
        Parameters:
        paramU : 'float'
            U parameter value
        paramV : 'float'
            V parameter value
        space : 'Space.Space'
            Coordinate space in which to perform this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMaya.MSpace.getPointAtParam`
        """
        pass
    def getTangents(self, paramInU, paramInV, space="'preTransform'"):
        """
        Retrieve the tangents in the U and V directions at the given parameter value on the surface. The returned tangent vectors are normalized.
        
        Parameters:
        paramInU : 'float'
            U parameter value at which to obtain tangents
        paramInV : 'float'
            V parameter value at which to obtain tangents
        space : 'Space.Space'
            Coordinate space for the returned vectors
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        Tuple['Vector', 'Vector']
        
        Derived from api method `maya.OpenMaya.MSpace.getTangents`
        """
        pass
    def hasHistoryOnCreate(self):
        """
        This method determines if the shape was created with history.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.hasHistoryOnCreate`
        """
        pass
    def intersect(self, rayStartingPoint, alongThisDirection, tolerance='0.001', space="'preTransform'", calculateDistance='False', calculateExactHit='False'):
        """
        This function determines the closest point of intersection of this spline surface with a ray (a vector at a point).
        
        Parameters:
        rayStartingPoint : 'Point'
            Starting location of ray to test.
        alongThisDirection : 'Vector'
            Direction of ray to test.
        tolerance : 'float'
            The epsilon value in the calculation.
        space : 'Space.Space'
            Specifies the coordinate system for this operation.
        
            values: 'transform', 'preTransform', 'object', 'world'
        calculateDistance : 'bool'
            Specifies whether to calculate the distance of the startPoint to the point of intersection
        calculateExactHit : 'bool'
            Specifies whether to determine if the point of intersection actually hit the object or just came within tolerance of it.
        
        
        Returns:
        Tuple['bool', 'float', 'float', 'Point', 'float', 'bool']
        
        Derived from api method `maya.OpenMaya.MSpace.intersect`
        """
        pass
    def isBezier(self):
        """
        Determine if the knot spacing gives us Bezier surface.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isBezier`
        """
        pass
    def isFlipNorm(self, region):
        """
        Determines whether the normal for the specified region is flipped. This method is only valid for trimmed surfaces.
        
        Parameters:
        region : 'int'
            Trimmed region to check. Must be in the range 0 to numRegions() - 1.
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isFlipNorm`
        """
        pass
    def isFoldedOnBispan(self):
        """
        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.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isFoldedOnBispan`
        """
        pass
    def isKnotU(self, param):
        """
        Check if the specified parameter value is a knot value.
        
        Parameters:
        param : 'float'
            parameter value to test
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isKnotU`
        """
        pass
    def isKnotV(self, param):
        """
        Check if the specified parameter value is a knot value.
        
        Parameters:
        param : 'float'
            parameter value to test
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isKnotV`
        """
        pass
    def isParamOnSurface(self, paramU, paramV):
        """
        Check if the specified parameter is on this surface.
        
        Parameters:
        paramU : 'float'
            U parameter value
        paramV : 'float'
            V parameter value
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isParamOnSurface`
        """
        pass
    def isPointInTrimmedRegion(self, u, v):
        """
        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.
        
        Parameters:
        u : 'float'
            u parameter of point on surface to test
        v : 'float'
            v parameter of point on surface to test
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isPointInTrimmedRegion`
        """
        pass
    def isPointOnSurface(self, point, tolerance='0.001', space="'preTransform'"):
        """
        Check if the given point is on this surface.
        
        Parameters:
        point : 'Point'
            Point to test
        tolerance : 'float'
            tolerance value to be used for computations
        space : 'Space.Space'
            Coordinate space for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MSpace.isPointOnSurface`
        """
        pass
    def isTrimmedSurface(self):
        """
        This method determines if this surface is a trimmed surface.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isTrimmedSurface`
        """
        pass
    def isUniform(self):
        """
        Determine if the knot spacing is uniform.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.isUniform`
        """
        pass
    def normal(self, paramInU, paramInV, space="'preTransform'"):
        """
        Retrieve the normal at the given parameter value on the surface.
        
        Parameters:
        paramInU : 'float'
            U parameter at which to obtain normal
        paramInV : 'float'
            V parameter at which to obtain normal
        space : 'Space.Space'
            Coordinate space for the returned vector
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        
        Returns:
        'Vector'
        
        Derived from api method `maya.OpenMaya.MSpace.normal`
        """
        pass
    def numBoundaries(self, region):
        """
        Returns the number of boundaries for the specified region. The surface must be a trimmed surface.
        
        Parameters:
        region : 'int'
            The trimmed region to examine
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numBoundaries`
        """
        pass
    def numCVsInU(self, editableOnly='True'):
        """
        Returns the number of CVs in the U direction.
        
        :Parameters:
        editableOnly : `bool`
            If editableOnly evaluates to True (default), then this will return
            the number of cvs that can be actually edited (and also the highest
            index that may be used for u - ie, if
                mySurf.numCVsInU(editableOnly=True) == 4
            then allowable u indices go from
                mySurf.cv[0][*] to mySurf.cv[3][*]
        
            If editablyOnly is False, then this will return the underlying
            number of cvs used to define the mathematical curve in u -
            degreeU + numSpansInU.
        
            These will only differ if the form in u is 'periodic', in which
            case the editable number will be numSpansInU (as the last 'degree'
            cv's are 'locked' to be the same as the first 'degree' cvs).
            In all other cases, the number of cvs will be degreeU + numSpansInU.
        
        :Examples:
            >>> from pymel.core import *
            >>> # a periodic surface
            >>> mySurf = surface(name='periodicSurf1', du=3, dv=1, fu='periodic', fv='open', ku=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), kv=(0, 1), pw=[(4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1), (0, 5.5, 0, 1), (0, 5.5, -2.5, 1), (-4, 4, 0, 1), (-4, 4, -2.5, 1), (-5.5, 0, 0, 1), (-5.5, 0, -2.5, 1), (-4, -4, 0, 1), (-4, -4, -2.5, 1), (0, -5.5, 0, 1), (0, -5.5, -2.5, 1), (4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1)] )
            >>> sorted(mySurf.cv[:][0].indices())        # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((7, 0), label=None)]
            >>> mySurf.numCVsInU()
            8
            >>> mySurf.numCVsInU(editableOnly=False)
            11
            >>>
            >>> # an open surface
            >>> mySurf = surface(name='openSurf1', du=3, dv=1, fu='open', fv='open', ku=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), kv=(0, 1), pw=((4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1), (0, 5.5, 0, 1), (0, 5.5, -2.5, 1), (-4, 4, 0, 1), (-4, 4, -2.5, 1), (-5.5, 0, 0, 1), (-5.5, 0, -2.5, 1), (-4, -4, 0, 1), (-4, -4, -2.5, 1), (0, -5.5, 0, 1), (0, -5.5, -2.5, 1), (4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1)) )
            >>> sorted(mySurf.cv[:][0].indices())        # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((10, 0), label=None)]
            >>> mySurf.numCVsInU()
            11
            >>> mySurf.numCVsInU(editableOnly=False)
            11
        
        :rtype: `int`
        """
        pass
    def numCVsInV(self, editableOnly='True'):
        """
        Returns the number of CVs in the V direction.
        
        :Parameters:
        editableOnly : `bool`
            If editableOnly evaluates to True (default), then this will return
            the number of cvs that can be actually edited (and also the highest
            index that may be used for v - ie, if
                mySurf.numCVsInV(editableOnly=True) == 4
            then allowable v indices go from
                mySurf.cv[*][0] to mySurf.cv[*][3]
        
            If editablyOnly is False, then this will return the underlying
            number of cvs used to define the mathematical curve in v -
            degreeV + numSpansInV.
        
            These will only differ if the form in v is 'periodic', in which
            case the editable number will be numSpansInV (as the last 'degree'
            cv's are 'locked' to be the same as the first 'degree' cvs).
            In all other cases, the number of cvs will be degreeV + numSpansInV.
        
        :Examples:
            >>> from pymel.core import *
            >>> # a periodic surface
            >>> mySurf = surface(name='periodicSurf2', du=1, dv=3, fu='open', fv='periodic', ku=(0, 1), kv=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1), (0, 5.5, -2.5, 1), (-4, 4, -2.5, 1), (-5.5, 0, -2.5, 1), (-4, -4, -2.5, 1), (0, -5.5, -2.5, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1)] )
            >>> sorted(mySurf.cv[0].indices())         # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((0, 7), label='cv')]
            >>> mySurf.numCVsInV()
            8
            >>> mySurf.numCVsInV(editableOnly=False)
            11
            >>>
            >>> # an open surface
            >>> mySurf = surface(name='openSurf2', du=1, dv=3, fu='open', fv='open', ku=(0, 1), kv=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1), (0, 5.5, -2.5, 1), (-4, 4, -2.5, 1), (-5.5, 0, -2.5, 1), (-4, -4, -2.5, 1), (0, -5.5, -2.5, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1)] )
            >>> sorted(mySurf.cv[0].indices())          # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((0, 10), label='cv')]
            >>> mySurf.numCVsInV()
            11
            >>> mySurf.numCVsInV(editableOnly=False)
            11
        
        :rtype: `int`
        """
        pass
    def numEPsInU(self, editableOnly='True'):
        """
        Returns the number of EPs in the U direction.
        
        :Examples:
            >>> from pymel.core import *
            >>> # a periodic surface
            >>> mySurf = surface(name='periodicSurf3', du=3, dv=1, fu='periodic', fv='open', ku=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), kv=(0, 1), pw=[(4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1), (0, 5.5, 0, 1), (0, 5.5, -2.5, 1), (-4, 4, 0, 1), (-4, 4, -2.5, 1), (-5.5, 0, 0, 1), (-5.5, 0, -2.5, 1), (-4, -4, 0, 1), (-4, -4, -2.5, 1), (0, -5.5, 0, 1), (0, -5.5, -2.5, 1), (4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1)] )
            >>> sorted(mySurf.ep[:][0].indices())      # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((7, 0), label=None)]
            >>> mySurf.numEPsInU()
            8
            >>>
            >>> # an open surface
            >>> mySurf = surface(name='openSurf3', du=3, dv=1, fu='open', fv='open', ku=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), kv=(0, 1), pw=[(4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1), (0, 5.5, 0, 1), (0, 5.5, -2.5, 1), (-4, 4, 0, 1), (-4, 4, -2.5, 1), (-5.5, 0, 0, 1), (-5.5, 0, -2.5, 1), (-4, -4, 0, 1), (-4, -4, -2.5, 1), (0, -5.5, 0, 1), (0, -5.5, -2.5, 1), (4, -4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, 0, 1), (5.5, 0, -2.5, 1), (4, 4, 0, 1), (4, 4, -2.5, 1)] )
            >>> sorted(mySurf.ep[:][0].indices())      # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((8, 0), label=None)]
            >>> mySurf.numEPsInU()
            9
        
        :rtype: `int`
        """
        pass
    def numEPsInV(self, editableOnly='True'):
        """
        Returns the number of EPs in the V direction.
        
        :Examples:
            >>> from pymel.core import *
            >>> # a periodic surface
            >>> mySurf = surface(name='periodicSurf4', du=1, dv=3, fu='open', fv='periodic', ku=(0, 1), kv=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1), (0, 5.5, -2.5, 1), (-4, 4, -2.5, 1), (-5.5, 0, -2.5, 1), (-4, -4, -2.5, 1), (0, -5.5, -2.5, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1)] )
            >>> sorted(mySurf.ep[0][:].indices())      # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((0, 7), label=None)]
            >>> mySurf.numEPsInV()
            8
            >>>
            >>> # an open surface
            >>> mySurf = surface(name='openSurf4', du=1, dv=3, fu='open', fv='open', ku=(0, 1), kv=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), pw=[(4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (0, 5.5, 0, 1), (-4, 4, 0, 1), (-5.5, 0, 0, 1), (-4, -4, 0, 1), (0, -5.5, 0, 1), (4, -4, 0, 1), (5.5, 0, 0, 1), (4, 4, 0, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1), (0, 5.5, -2.5, 1), (-4, 4, -2.5, 1), (-5.5, 0, -2.5, 1), (-4, -4, -2.5, 1), (0, -5.5, -2.5, 1), (4, -4, -2.5, 1), (5.5, 0, -2.5, 1), (4, 4, -2.5, 1)] )
            >>> sorted(mySurf.ep[0][:].indices())      # doctest: +ELLIPSIS
            [ComponentIndex((0, 0), ... ComponentIndex((0, 8), label=None)]
            >>> mySurf.numEPsInV()
            9
        
        :rtype: `int`
        """
        pass
    def numEdges(self, region, boundary):
        """
        Return the number of edges for the specified trim boundary.
        
        Parameters:
        region : 'int'
            Region to examine
        boundary : 'int'
            Boundary to examine
        
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numEdges`
        """
        pass
    def numKnotsInU(self):
        """
        Returns the number of knots in U including multiple end knots (spans + 2 * degree - 1).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numKnotsInU`
        """
        pass
    def numKnotsInV(self):
        """
        Returns the number of knots in V including multiple end knots (spans + 2 * degree - 1).
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numKnotsInV`
        """
        pass
    def numNonZeroSpansInU(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numNonZeroSpansInU`
        """
        pass
    def numNonZeroSpansInV(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numNonZeroSpansInV`
        """
        pass
    def numPatches(self):
        """
        Returns the number of non-zero patches in this surface.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numPatches`
        """
        pass
    def numPatchesInU(self):
        """
        Returns the number of non-zero patches along u, in this surface.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numPatchesInU`
        """
        pass
    def numPatchesInV(self):
        """
        Returns the number of non-zero patches along v, in this surface.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numPatchesInV`
        """
        pass
    def numRegions(self):
        """
        Returns the number of trimmed regions for this surface or 0 if the surface is not a trimmed surface.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numRegions`
        """
        pass
    def numSpansInU(self):
        """
        Returns the number of spans in the u direction.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numSpansInU`
        """
        pass
    def numSpansInV(self):
        """
        Returns the number of spans in the v direction.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numSpansInV`
        """
        pass
    def numUVs(self):
        """
        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.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.numUVs`
        """
        pass
    def projectCurve(self, curve, direction='None', constructionHistory='False'):
        """
        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.
        
        Parameters:
        curve : 'PyNode'
            curve to be projected
        direction : 'Vector'
            direction of projection. If this is null then the surface normals is used
        constructionHistory : 'bool'
            keep construction history
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.projectCurve`
        """
        pass
    def removeKnotInU(self, atThisParam, removeAll='False'):
        """
        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.
        
        Parameters:
        atThisParam : 'float'
            Parameter of knot to be removed
        removeAll : 'bool'
            If true then remove all the knots at the given parameter, otherwise remove all except one knot
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.removeKnotInU`
        """
        pass
    def removeKnotInV(self, atThisParam, removeAll='False'):
        """
        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.
        
        Parameters:
        atThisParam : 'float'
            Parameter of knot to be removed
        removeAll : 'bool'
            If true then remove all the knots at the given parameter, otherwise remove all except one knot
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.removeKnotInV`
        """
        pass
    def removeOneKnotInU(self, atThisParam):
        """
        Remove one U knot at the specified parameter value from this surface.
        
        Parameters:
        atThisParam : 'float'
            Parameter of knot to be removed
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.removeOneKnotInU`
        """
        pass
    def removeOneKnotInV(self, atThisParam):
        """
        Remove one V knot at the specified parameter value from this surface.
        
        Parameters:
        atThisParam : 'float'
            Parameter of knot to be removed
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.removeOneKnotInV`
        """
        pass
    def setCV(self, indexU, indexV, pt, space="'preTransform'"):
        """
        Set the location of the specified CV.
        
        Parameters:
        indexU : 'int'
            U index of CV
        indexV : 'int'
            V index of CV
        pt : 'Point'
            new location for the CV
        space : 'Space.Space'
            coordinate space for the CV
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setCV`
        """
        pass
    def setCVs(self, array, space="'preTransform'"):
        """
        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".
        
        Parameters:
        array : List['Point']
            The array of point values of the CVs
        space : 'Space.Space'
            specifies the coordinate system for this operation
        
            values: 'transform', 'preTransform', 'object', 'world'
        
        Derived from api method `maya.OpenMaya.MSpace.setCVs`
        """
        pass
    def setKnotInU(self, index, param):
        """
        Set the value of the given existing knot at the specified U index. U knots are indexed from 0 to numKnotsInU()-1. Note that this method does not insert a new knot, it simply changes the value of a knot that already exists.
        
        Parameters:
        index : 'int'
            The U index of the existing knot to be set
        param : 'float'
            The new parameter value for the knot
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.setKnotInU`
        """
        pass
    def setKnotInV(self, index, param):
        """
        Set the value of the given existing knot at the specified V index. V knots are indexed from 0 to numKnotsInV()-1. Note that this routine does not insert a new knot, it simply changes the value of a knot that already exists.
        
        Parameters:
        index : 'int'
            The V index of the existing knot to be set
        param : 'float'
            The new value for the knot
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.setKnotInV`
        """
        pass
    def setKnotsInU(self, array, startIndex, endIndex):
        """
        Set the specified U knot values for this surface.
        
        Parameters:
        array : List['float']
            The knot values to be set
        startIndex : 'int'
            The start knot index
        endIndex : 'int'
            The end knot index
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.setKnotsInU`
        """
        pass
    def setKnotsInV(self, array, startIndex, endIndex):
        """
        Set the specified V knot values for this surface.
        
        Parameters:
        array : List['float']
            The knot values to be set
        startIndex : 'int'
            The start knot index
        endIndex : 'int'
            The end knot index
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.setKnotsInV`
        """
        pass
    def tesselate(self, parms="'MTesselationParams::fsDefaultTesselationParams'", parentOrOwner="'MObject::kNullObj'"):
        """
        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).
        
        Parameters:
        parms : 'MTesselationParams'
            Tesselation parameters parentOrOwner the DAG parent or kMeshData the new mesh will belong to ReturnStatus Status code If parentOrOwner is nullptr then the transform for this surface is returned If parentOrOwner is a DAG object then the new surface shape is returned The surface geometry is returned if parentOrOwner is of type kMeshData Status Codes: MS::kSuccess Method successful MS::kLicenseFailure Application not licensed for attempted operation MS::kFailure Object error
        parentOrOwner : 'PyNode'
            the DAG parent or kMeshData the new mesh will belong to
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.tesselate`
        """
        pass
    def trim(self, locatorU, locatorV, constructionHistory='False'):
        """
        Trim this surface to its curves on surface. Regions which are kept are specified by passing in two arrays of u,v parameters.
        
        Parameters:
        locatorU : List['float']
            array of U parameters indicating regions to keep
        locatorV : List['float']
            array of V parameters indicating regions to keep
        constructionHistory : 'bool'
            keep construction history
        
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.trim`
        """
        pass
    def updateSurface(self):
        """
        This method signals that this surface has changed and needs to be recalculated.
        Derived from api method `maya.OpenMaya.MFnNurbsSurface.updateSurface`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The cmd creates a NURBS spline surface (rational or non rational). The surface
        is created by specifying control vertices (CV's) and knot sequences in the U and
        V direction.  You cannot query the properties of the surface using this command.
        See examples below.
        
        Flags:
        - degreeU : du                   (int)           [create]
            Degree in surface U direction.  Default is degree 3.
        
        - degreeV : dv                   (int)           [create]
            Degree in surface V direction.  Default is degree 3.
        
        - formU : fu                     (unicode)       [create]
            The string for open is open, for closed is closedor for periodic is periodicin
            U.
        
        - formV : fv                     (unicode)       [create]
            The string for open is open, for closed is closedor for periodic is periodicin
            V.
        
        - knotU : ku                     (float)         [create]
            Knot value(s) in U direction.  One flag per knot value. There must be
            (numberOfPointsInU + degreeInU - 1) knots and the knot vector must be non-
            decreasing.
        
        - knotV : kv                     (float)         [create]
            Knot value(s) in V direction.  One flag per knot value. There must be
            (numberOfPointsInV + degreeInV - 1) knots and the knot vector must be non-
            decreasing.
        
        - name : n                       (unicode)       [create]
            Name to use for new transforms.
        
        - objectSpace : ob               (bool)          [create]
            Should the operation happen in objectSpace?
        
        - point : p                      (float, float, float) [create]
            To specify non rational CV with (x, y, z) values.  linearmeans that this flag
            can take values with units.  Note that you must specify (degree+1) surface
            points in any direction to create a visible surface span.  eg.  if the surface
            is degree 3 in the U direction, you must specify 4 CVs in the U direction.
            Points are specified in rows of U and columns of V.  If you want to incorporate
            units, add the unit name to the value, eg. -p 3.3in 5.5ft 6.6yd
        
        - pointWeight : pw               (float, float, float, float) [create]
            To specify rational CV with (x, y, z, w) values.  linearmeans that this flag can
            take values with units.  Note that you must specify (degree+1) surface points in
            any direction to create a visible surface span.  eg.  if the surface is degree 3
            in the U direction, you must specify 4 CVs in the U direction. Points are
            specified in rows of U and columns of V.
        
        - worldSpace : ws                (bool)          [create]
            Should the operation happen in worldSpace?                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.surface`
        """
        pass
    BoundaryType = {}
    
    
    Form = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'surface'
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class THsurfaceShape(SurfaceShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class NParticle(NBase):
    def floatValue(self, val='True', **kwargs):
        """
        Used only in per particle attribute edit.  Specifies that the edit is of a float attribute and must be followed by the new float value.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the name of the attribute being queried or edited.       
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getCache(self, **kwargs):
        """
        Turns caching on/off for the particle shape.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getConserve(self, **kwargs):
        """
        Conservation of momentum control (between 0 and 1).  Specifies the fraction of the particle shape's existing momentum which is conserved from frame to frame. A value of 1 (the default) corresponds to true Newtonian physics, in which momentum is conserved.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getDynamicAttrList(self, **kwargs):
        """
        Returns a list of the dynamic attributes in the object.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getGridSpacing(self, **kwargs):
        """
        Spacing between particles in the grid.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getInherit(self, **kwargs):
        """
        Inherit this fraction (0-1) of emitting object's velocity.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getJitterBasePoint(self, **kwargs):
        """
        Base point (center point) for jitters.  The command will create one swatch of jitters for each base point.  It will pair up other flags with base points in the order they are given in the command line.  If not enough instances of the other flags are availble, the last one on the line with be used for all other instances of -jpb.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getJitterRadius(self, **kwargs):
        """
        Max radius from the center to place the particle instances.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getLowerLeft(self, **kwargs):
        """
        Lower left point of grid.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getNumJitters(self, **kwargs):
        """
        Number of jitters (instances) per particle.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getOrder(self, **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the zero-based order (index) of the particle whose attribute is being queried  or edited in the particle array. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getParticleId(self, **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the id of the particle whose attribute is being queried or edited. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getPerParticleDouble(self, **kwargs):
        """
        Returns a list of the per-particle double attributes, excluding initial-state, cache, and information-only attributes.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getPerParticleVector(self, **kwargs):
        """
        Returns a list of the per-particle vector attributes, excluding initial-state, cache, and information-only attributes.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getShapeName(self, **kwargs):
        """
        Specify the shape name used for geometry instancing. DO not confuse this with the -n flag which names the particle object.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def getUpperRight(self, **kwargs):
        """
        Upper right point of grid.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the name of the attribute being queried or edited.       
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def setCache(self, val='True', **kwargs):
        """
        Turns caching on/off for the particle shape.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def setConserve(self, val='True', **kwargs):
        """
        Conservation of momentum control (between 0 and 1).  Specifies the fraction of the particle shape's existing momentum which is conserved from frame to frame. A value of 1 (the default) corresponds to true Newtonian physics, in which momentum is conserved.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def setInherit(self, val='True', **kwargs):
        """
        Inherit this fraction (0-1) of emitting object's velocity.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def setOrder(self, val='True', **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the zero-based order (index) of the particle whose attribute is being queried  or edited in the particle array. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def setParticleId(self, val='True', **kwargs):
        """
        Used in per particle attribute query and edit. Specifies the id of the particle whose attribute is being queried or edited. Querying the value of a per particle attribute requires the -attribute and -id or -order flags and their arguments to precede the -q flag.       
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def setShapeName(self, val='True', **kwargs):
        """
        Specify the shape name used for geometry instancing. DO not confuse this with the -n flag which names the particle object.                  
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    def vectorValue(self, val='True', **kwargs):
        """
        Used only in per particle attribute edit.  Specifies that the edit is of a vector attribute and must be followed by all three float values for the vector.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The nParticle command creates a new nParticle object from a list of world space
        points. If an nParticle object is created, the command returns the names of the
        new particle shape and its associated particle object dependency node. If an
        object was queried, the results of the query are returned. Per particle
        attributes can be queried using the particleId or the order of the particle in
        the particle array. If an object was edited, nothing is returned.
        
        Flags:
        - attribute : at                 (unicode)       [query,edit]
            Used in per particle attribute query and edit. Specifies the name of the
            attribute being queried or edited.
        
        - cache : ch                     (bool)          [create,query,edit]
            Turns caching on/off for the particle shape.
        
        - conserve : c                   (float)         [query,edit]
            Conservation of momentum control (between 0 and 1).  Specifies the fraction of
            the particle shape's existing momentum which is conserved from frame to frame. A
            value of 1 (the default) corresponds to true Newtonian physics, in which
            momentum is conserved.
        
        - count : ct                     (bool)          [query]
            Returns the number of particles in the object.
        
        - deleteCache : dc               (bool)          [create]
            Deletes the particle shapes cache. This command is not undoable.
        
        - dynamicAttrList : dal          (bool)          [query]
            Returns a list of the dynamic attributes in the object.
        
        - floatValue : fv                (float)         [edit]
            Used only in per particle attribute edit.  Specifies that the edit is of a float
            attribute and must be followed by the new float value.
        
        - gridSpacing : grs              (float)         [create,query]
            Spacing between particles in the grid.
        
        - inherit : i                    (float)         [query,edit]
            Inherit this fraction (0-1) of emitting object's velocity.
        
        - jitterBasePoint : jbp          (float, float, float) [create,query]
            Base point (center point) for jitters.  The command will create one swatch of
            jitters for each base point.  It will pair up other flags with base points in
            the order they are given in the command line.  If not enough instances of the
            other flags are availble, the last one on the line with be used for all other
            instances of -jpb.
        
        - jitterRadius : jr              (float)         [create,query]
            Max radius from the center to place the particle instances.
        
        - lowerLeft : ll                 (float, float, float) [create,query]
            Lower left point of grid.
        
        - name : n                       (unicode)       [query,edit]
            name of particle object
        
        - numJitters : nj                (int)           [create,query]
            Number of jitters (instances) per particle.
        
        - order : order                  (int)           [query,edit]
            Used in per particle attribute query and edit. Specifies the zero-based order
            (index) of the particle whose attribute is being queried  or edited in the
            particle array. Querying the value of a per particle attribute requires the
            -attribute and -id or -order flags and their arguments to precede the -q flag.
        
        - particleId : id                (int)           [query,edit]
            Used in per particle attribute query and edit. Specifies the id of the particle
            whose attribute is being queried or edited. Querying the value of a per particle
            attribute requires the -attribute and -id or -order flags and their arguments to
            precede the -q flag.
        
        - perParticleDouble : ppd        (bool)          [query]
            Returns a list of the per-particle double attributes, excluding initial-state,
            cache, and information-only attributes.
        
        - perParticleVector : ppv        (bool)          [query]
            Returns a list of the per-particle vector attributes, excluding initial-state,
            cache, and information-only attributes.
        
        - position : p                   (float, float, float) []
            World-space position of each particle.
        
        - shapeName : sn                 (unicode)       [query,edit]
            Specify the shape name used for geometry instancing. DO not confuse this with
            the -n flag which names the particle object.
        
        - upperRight : ur                (float, float, float) [create,query]
            Upper right point of grid.
        
        - vectorValue : vv               (float, float, float) [edit]
            Used only in per particle attribute edit.  Specifies that the edit is of a
            vector attribute and must be followed by all three float values for the vector.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.nParticle`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FluidShape(SurfaceShape):
    def create2D(self, Xres, Yres, Xdim, Ydim, parent="'MObject::kNullObj'"):
        """
        Creates a fluid object from the specified data and sets this function set to operate on the new fluid object.
        
        Parameters:
        Xres : 'int'
            number of fluid grid cells in the x dimension
        Yres : 'int'
            number of fluid grid cells in the y dimension
        Xdim : 'float'
            object space size in the x dimension
        Ydim : 'float'
            object space size in the y dimension
        parent : 'PyNode'
            specifies what to do with the new fluid object. If a DAG object or NULL is given then a transform will be created for the new fluid shape and placed under the specified (optional)parent.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.create2D`
        """
        pass
    def create3D(self, Xres, Yres, Zres, Xdim, Ydim, Zdim, parent="'MObject::kNullObj'"):
        """
        Creates a fluid object from the specified data and sets this function set to operate on the new fluid object.
        
        Parameters:
        Xres : 'int'
            number of fluid grid cells in the x dimension
        Yres : 'int'
            number of fluid grid cells in the y dimension
        Zres : 'int'
            number of fluid grid cells in the z dimension
        Xdim : 'float'
            object space size in the x dimension
        Ydim : 'float'
            object space size in the y dimension
        Zdim : 'float'
            object space size in the z dimension
        parent : 'PyNode'
            specifies what to do with the new fluid object. If a DAG object or NULL is given then a transform will be created for the new fluid shape and placed under the specified (optional)parent.
        
        
        Returns:
        'PyNode'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.create3D`
        """
        pass
    def density(self):
        """
        This method returns a pointer to the storage for the density data in the fluid. The size of this array can be obtained using the "gridSize" call.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.density`
        """
        pass
    def emitIntoArrays(self, val, x, y, z, density, heat, fuel, doColor, emitColor):
        """
        Use this method to add density, heat, fuel, and/or color to a particular voxel of a fluid.
        
        Parameters:
        val : 'float'
            multiplier applied to the specified density, heat, and fuel values.
        x : 'int'
            voxel index in x
        y : 'int'
            voxel index in y
        z : 'int'
            voxel index in z
        density : 'float'
            amount of density to add to the voxel
        heat : 'float'
            amount of heat to add to the voxel
        fuel : 'float'
            amount of fuel to add to the voxel
        doColor : 'bool'
            if true, then color specified by "emitColor" will be blended into the voxel's current color, with the blend coefficients being determined by the amount of density that is being added to the voxel.
        emitColor : 'Color'
            color to be blended into the voxel.
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.emitIntoArrays`
        """
        pass
    def expandToInclude(self, min, max):
        """
        Tells the fluid shape to autoresize to include these two points This would normally be used in a fluid emitter node if the fluid had resizeToEmitter turned on. This may fail if the fluid is not autoRise and resizeToEmitter, or if the fluid has reached its maxResolution
        
        Parameters:
        min : 'Point'
            point at lower corner of bounding box
        max : 'Point'
            point at upper corner of boinding box
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.expandToInclude`
        """
        pass
    def falloff(self):
        """
        This method returns a pointer to the storage for the falloff data in the fluid. The size of this array can be obtained using the "gridSize" call.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.falloff`
        """
        pass
    def fuel(self):
        """
        This method returns a pointer to the storage for the fuel data in the fluid. The size of this array can be obtained using the "gridSize" call.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.fuel`
        """
        pass
    def getColorMode(self):
        """
        Get the modes by which the color values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Returns:
        'FluidShape.ColorMethod'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getColorMode`
        """
        pass
    def getColors(self):
        """
        This method returns pointers to the storage for the color data in the fluid. The size of these arrays can be obtained using the "gridSize" call.
        
        Returns:
        Tuple['float', 'float', 'float']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getColors`
        """
        pass
    def getCoordinateMode(self):
        """
        Get the modes by which the UVW coordinates values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Returns:
        'FluidShape.CoordinateMethod'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getCoordinateMode`
        """
        pass
    def getCoordinates(self):
        """
        This method returns pointers to the storage for the uvw coordinate data in the fluid. The size of these arrays can be obtained using the "gridSize" call. The uvw values supply the 3D texture mapping coordinates for each cell.
        
        Returns:
        Tuple['float', 'float', 'float']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getCoordinates`
        """
        pass
    def getDensityMode(self):
        """
        Get the modes by which the density values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Returns:
        Tuple['FluidShape.FluidMethod', 'FluidShape.FluidGradient']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getDensityMode`
        """
        pass
    def getDimensions(self):
        """
        Gets the dimensions of the fluid. The dimensions give the object space size of the fluid object in each direction.
        
        Returns:
        Tuple['float', 'float', 'float']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getDimensions`
        """
        pass
    def getFalloffMode(self):
        """
        Get the modes by which the falloff values in the grid are determined. If the falloff grid is enabled, its values must be set by the user.
        
        Returns:
        'FluidShape.FalloffMethod'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getFalloffMode`
        """
        pass
    def getForceAtPoint(self, point, velocity, mass, deltaTime='0.041666666666666664'):
        """
        Compute the force of the fluid as a field on an array of points, given their position, velocity, and mass.
        
        Parameters:
        point : List['Point']
            array of positions for each point.
        velocity : List['Vector']
            array of velocities for each point. If the length of the velocity array is 0, a velocity of 0.0 is assumed for all the points.
        mass : List['float']
            array of mass values for each point. If the length of the mass array is 0, a mass of 1.0 is assumed for all the points.
        deltaTime : 'float'
            time increment in seconds. Default is (1.0 / 24.0 fps).
        
        
        Returns:
        List['Vector']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getForceAtPoint`
        """
        pass
    def getFuelMode(self):
        """
        Get the modes by which the fuel values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Returns:
        Tuple['FluidShape.FluidMethod', 'FluidShape.FluidGradient']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getFuelMode`
        """
        pass
    def getResolution(self):
        """
        Gets the resolution of the fluid. The resolution gives the number of cells in the fluid grid in each direction.
        
        Returns:
        Tuple['int', 'int', 'int']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getResolution`
        """
        pass
    def getTemperatureMode(self):
        """
        Get the modes by which the temperature values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Returns:
        Tuple['FluidShape.FluidMethod', 'FluidShape.FluidGradient']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getTemperatureMode`
        """
        pass
    def getVelocity(self):
        """
        This method returns pointers to the storage for the velocity data in the fluid. The size of these arrays can be obtained using the "velocityGridSizes" call.
        
        Returns:
        Tuple['float', 'float', 'float']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getVelocity`
        """
        pass
    def getVelocityMode(self):
        """
        Get the modes by which the velocity values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Returns:
        Tuple['FluidShape.FluidMethod', 'FluidShape.FluidGradient']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.getVelocityMode`
        """
        pass
    def gridSize(self):
        """
        Returns the number of elements in the grid. This is equal to (x resolution * y resolution * z resolution). This routine is provided as a convenience to be used with the methods that give direct access to the fluid data. This gives the upper bound on the arrays. This size applies to all grids except for the 3 velocity grids.
        
        Returns:
        'int'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.gridSize`
        """
        pass
    def isAutoResize(self):
        """
        Is this an autoresize fluid?
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.isAutoResize`
        """
        pass
    def isResizeToEmitter(self):
        """
        If this is an autoresize fluid, should it also resize to the emitter
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.isResizeToEmitter`
        """
        pass
    def pressure(self):
        """
        This method returns a pointer to the storage for the pressure data in the fluid. The size of this array can be obtained using the "gridSize" call. Note that the pressure data only exists if the velocity method is kStaticGrid or kDynamicGrid
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.pressure`
        """
        pass
    def setColorMode(self, method):
        """
        Set the modes by which the color values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Parameters:
        method : 'FluidShape.ColorMethod'
            method for determining the fluid color in the grid
        
            values: 'useShadingColor', 'staticColorGrid', 'dynamicColorGrid'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setColorMode`
        """
        pass
    def setCoordinateMode(self, method):
        """
        Set the modes by which the UVW coordinate values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Parameters:
        method : 'FluidShape.CoordinateMethod'
            method for determining the fluid UVW coordinates in the grid
        
            values: 'fixed', 'grid'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setCoordinateMode`
        """
        pass
    def setDensityMode(self, method, gradient):
        """
        Set the modes by which the density values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Parameters:
        method : 'FluidShape.FluidMethod'
            method for determining the fluid density in the grid
        
            values: 'zero', 'staticGrid', 'dynamicGrid', 'gradient'
        gradient : 'FluidShape.FluidGradient'
            gradient type, only used if the method is kGradient
        
            values: 'constant', 'XGradient', 'YGradient', 'ZGradient', 'negXGradient', 'negYGradient', 'negZGradient', 'centerGradient'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setDensityMode`
        """
        pass
    def setFalloffMode(self, method):
        """
        Set the modes by which the shader falloff values in the grid are determined. If the falloff grid is enabled, its values must be set by the user.
        
        Parameters:
        method : 'FluidShape.FalloffMethod'
            method for determining the falloff value in the grid
        
            values: 'noFalloffGrid', 'staticFalloffGrid'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setFalloffMode`
        """
        pass
    def setFuelMode(self, method, gradient):
        """
        Set the modes by which the fuel values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation. The fuel value for a cell can be thought of as the amount of fuel contained in the cell that will be consumed during the simulation.
        
        Parameters:
        method : 'FluidShape.FluidMethod'
            method for determining the fluid fuel in the grid
        
            values: 'zero', 'staticGrid', 'dynamicGrid', 'gradient'
        gradient : 'FluidShape.FluidGradient'
            gradient type, only used if the method is kGradient
        
            values: 'constant', 'XGradient', 'YGradient', 'ZGradient', 'negXGradient', 'negYGradient', 'negZGradient', 'centerGradient'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setFuelMode`
        """
        pass
    def setSize(self, Xres, Yres, Zres, Xdim, Ydim, Zdim, resample):
        """
        Sets the size and resolution of the grid. The resolution parameters control the number of cells in the fluid grid and the dimension parameters set the size of the fluid shape in object space.
        
        Parameters:
        Xres : 'int'
            number of fluid grid cells in the x dimension
        Yres : 'int'
            number of fluid grid cells in the y dimension
        Zres : 'int'
            number of fluid grid cells in the z dimension
        Xdim : 'float'
            object space size in the x dimension
        Ydim : 'float'
            object space size in the y dimension
        Zdim : 'float'
            object space size in the z dimension
        resample : 'bool'
            true if the previous contents of the grid should be scaled to fit the new size by resampling the previous data at the new resolution
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setSize`
        """
        pass
    def setTemperatureMode(self, method, gradient):
        """
        Set the modes by which the temperature values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Parameters:
        method : 'FluidShape.FluidMethod'
            method for determining the fluid temperature in the grid
        
            values: 'zero', 'staticGrid', 'dynamicGrid', 'gradient'
        gradient : 'FluidShape.FluidGradient'
            gradient type, only used if the method is kGradient
        
            values: 'constant', 'XGradient', 'YGradient', 'ZGradient', 'negXGradient', 'negYGradient', 'negZGradient', 'centerGradient'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setTemperatureMode`
        """
        pass
    def setVelocityMode(self, method, gradient):
        """
        Set the modes by which the velocity values in the grid are determined. The values may be set by the user in various ways, or they may be computed as part of a simulation.
        
        Parameters:
        method : 'FluidShape.FluidMethod'
            method for determining the fluid velocity in the grid
        
            values: 'zero', 'staticGrid', 'dynamicGrid', 'gradient'
        gradient : 'FluidShape.FluidGradient'
            gradient type, only used if the method is kGradient
        
            values: 'constant', 'XGradient', 'YGradient', 'ZGradient', 'negXGradient', 'negYGradient', 'negZGradient', 'centerGradient'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.setVelocityMode`
        """
        pass
    def temperature(self):
        """
        This method returns a pointer to the storage for the temperature data in the fluid. The size of this array can be obtained using the "gridSize" call.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.temperature`
        """
        pass
    def toGridIndex(self, objectSpacePoint):
        """
        For the given point in object space, get the grid indices of the voxel that it happens to lie in. If the point is outside the fluid, the method returns false, and the indices should not be used.
        
        Parameters:
        objectSpacePoint : 'Point'
            an object space location
        
        
        Returns:
        Tuple['bool', ('int', 'int', 'int')]
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.toGridIndex`
        """
        pass
    def updateGrid(self):
        """
        Tells the fluid shape that the contents of the fluid grid has changed. It is necessary to call this routine after modifying internal fluid data via a pointer recieved from any of the access routines in this function set. Failure to call this will result in the fluid not drawing with your changes.
        Derived from api method `maya.OpenMayaFX.MFnFluid.updateGrid`
        """
        pass
    def velocityGridSizes(self):
        """
        Returns the number of elements in the velocity grids. X velocity size = (x resolution+1 * y resolution * z resolution). Y velocity size = (x resolution * y resolution+1 * z resolution). Z velocity size = (x resolution * y resolution * z resolution+1).
        
        Returns:
        Tuple['int', 'int', 'int']
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.velocityGridSizes`
        """
        pass
    def voxelCenterPosition(self, xi, yi, zi):
        """
        For the given voxel, get the location of the center in object space. If the voxel indices are not valid, the point may not be set to a valid point
        
        Parameters:
        xi : 'int'
            the voxel x index
        yi : 'int'
            the voxel y index
        zi : 'int'
            the voxel z index
        
        
        Returns:
        'Point'
        
        Derived from api method `maya.OpenMayaFX.MFnFluid.voxelCenterPosition`
        """
        pass
    ColorMethod = {}
    
    
    CoordinateMethod = {}
    
    
    FalloffMethod = {}
    
    
    FluidGradient = {}
    
    
    FluidMethod = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BezierCurve(NurbsCurve):
    __melnode__ = []
    
    
    __readonly__ = {}


class AreaLight(NonExtendedLightShapeNode):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class DirectionalLight(NonExtendedLightShapeNode):
    def getDiscRadius(self, **kwargs):
        """
        Radius of shadow disc.                  
        
        
        Derived from mel command `maya.cmds.directionalLight`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        True if the light is exclusively assigned                  
        
        
        Derived from mel command `maya.cmds.directionalLight`
        """
        pass
    def getRgb(self, **kwargs):
        """
        RGB colour of the light                  
        
        
        Derived from mel command `maya.cmds.directionalLight`
        """
        pass
    def getShadowAngle(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnDirectionalLight.shadowAngle`
        """
        pass
    def getShadowDither(self, **kwargs):
        """
        Shadow dithering value.                  
        
        
        Derived from mel command `maya.cmds.directionalLight`
        """
        pass
    def getShadowSamples(self, **kwargs):
        """
        Numbr of shadow samples to use                  
        
        
        Derived from mel command `maya.cmds.directionalLight`
        """
        pass
    def getSoftShadow(self, **kwargs):
        """
        True if soft shadowing is to be enabled                  
        
        
        Derived from mel command `maya.cmds.directionalLight`
        """
        pass
    def getUseLightPosition(self):
        """
        Retrieves the value of the "useLightPosition" attribute of a directional light. This attribute determines if the objects behind the light will cast shadows.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnDirectionalLight.useLightPosition`
        """
        pass
    def setShadowAngle(self, shadow_angle):
        """
        Sets the value of the "shadowAngle" attribute of a directional light node.
        
        Parameters:
        shadow_angle : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnDirectionalLight.setShadowAngle`
        """
        pass
    def setUseLightPosition(self, use_light_position):
        """
        Sets the value of the "useLightPosition" attribute of a directional light.
        
        Parameters:
        use_light_position : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnDirectionalLight.setUseLightPosition`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        TlightCmd is the base class for other light commands. TnonAmbientLightCmd is a
        class that looks like a command but is not.  It is a base class for the
        extended/nonExtended lights. TnonExtendedLightCmd is a base class and not a real
        command. It is inherited by several lights: TpointLight, TdirectionalLight,
        TspotLight etc. The directionalLight command is used to edit the parameters of
        existing directionalLights, or to create new ones. The default behaviour is to
        create a new directionallight. This is the commmand that instantiates an
        directionalLight or edits the parameters of an existing one.
        TdirectionalLightCmd inherits from TnonExtendedLightCmd which defines softShadow
        flags. See TlightCmd for a global picture of the light commands.
        TdirectionalLightCmd behaves like any other command, it has flags, saves undo
        information etc. the only slightly different behaviour is that it calls up to
        TnonExtendedLightCmd to complete the functionality of the command.
        
        Flags:
        - decayRate : d                  (int)           [create]
            Decay rate of the light (0-no decay, 1-slow, 2-realistic, 3-fast)
        
        - discRadius : drs               (float)         [create,query]
            Radius of shadow disc.
        
        - exclusive : exc                (bool)          [create,query]
            True if the light is exclusively assigned
        
        - intensity : i                  (float)         [create,query]
            Intensity of the light
        
        - name : n                       (unicode)       [create,query]
            Name of the light
        
        - position : pos                 (float, float, float) [create,query]
            Position of the light
        
        - rgb : rgb                      (float, float, float) [create,query]
            RGB colour of the light
        
        - rotation : rot                 (float, float, float) [create,query]
            Rotation of the light for orientation, where applicable
        
        - shadowColor : sc               (float, float, float) [create,query]
            Color of the light's shadow
        
        - shadowDither : sd              (float)         [create,query]
            Shadow dithering value.
        
        - shadowSamples : sh             (int)           [create,query]
            Numbr of shadow samples to use
        
        - softShadow : ss                (bool)          [create,query]
            True if soft shadowing is to be enabled
        
        - useRayTraceShadows : rs        (bool)          [create,query]
            True if ray trace shadows are to be used                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.directionalLight`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class SpotLight(NonExtendedLightShapeNode):
    def getBarnDoorAngle(self, which_door):
        """
        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.
        
        Parameters:
        which_door : 'SpotLight.MBarnDoor'
            which barn door to return.
        
            values: 'left', 'right', 'top', 'bottom'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.barnDoorAngle`
        """
        pass
    def getBarnDoors(self):
        """
        Retrieves the value of the "barnDoors" attribute of a light node. This attribute determines whether or not the light uses barn doors.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.barnDoors`
        """
        pass
    def getBottomBarnDoorAngle(self, **kwargs):
        """
        Angle of the bottom of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getConeAngle(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.coneAngle`
        """
        pass
    def getDiscRadius(self, **kwargs):
        """
        Radius of shadow disc.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getDropOff(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.dropOff`
        """
        pass
    def getEndDistance(self, which_region):
        """
        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.
        
        Parameters:
        which_region : 'SpotLight.MDecayRegion'
            the decay region whose endDistance attribute is to be retrieved.
        
            values: 'first', 'second', 'third'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.endDistance`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        True if the light is exclusively assigned                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getLeftBarnDoorAngle(self, **kwargs):
        """
        Angle of the left of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getPenumbra(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.penumbraAngle`
        """
        pass
    def getRgb(self, **kwargs):
        """
        RGB colour of the light                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getRightBarnDoorAngle(self, **kwargs):
        """
        Angle of the right of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getShadowDither(self, **kwargs):
        """
        Shadow dithering value.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getShadowSamples(self, **kwargs):
        """
        Numbr of shadow samples to use                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getSoftShadow(self, **kwargs):
        """
        True if soft shadowing is to be enabled                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getStartDistance(self, which_region):
        """
        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.
        
        Parameters:
        which_region : 'SpotLight.MDecayRegion'
            the decay region whose startDistance attribute is to be retrieved.
        
            values: 'first', 'second', 'third'
        
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.startDistance`
        """
        pass
    def getTopBarnDoorAngle(self, **kwargs):
        """
        Angle of the top of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def getUseDecayRegions(self):
        """
        Retrieves the value of the "useDecayRegions" attribute of a light node. This attribute determines whether or not the light uses decay regions.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.useDecayRegions`
        """
        pass
    def setBarnDoorAngle(self, which_door, barn_door_angle):
        """
        Sets the value of the appropriate barn door angle attribute of a light node.
        
        Parameters:
        which_door : 'SpotLight.MBarnDoor'
            Which barn door to return.
        
            values: 'left', 'right', 'top', 'bottom'
        barn_door_angle : 'float'
            New value for the barn door.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setBarnDoorAngle`
        """
        pass
    def setBarnDoors(self, barn_doors):
        """
        Sets the value of the "barnDoors" attribute of a light node.
        
        Parameters:
        barn_doors : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setBarnDoors`
        """
        pass
    def setBottomBarnDoorAngle(self, val='True', **kwargs):
        """
        Angle of the bottom of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def setConeAngle(self, cone_angle):
        """
        Sets the value of the "coneAngle" attribute of a light node.
        
        Parameters:
        cone_angle : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setConeAngle`
        """
        pass
    def setDropOff(self, drop_off):
        """
        Sets the value of the "dropOff" attribute of a light node.
        
        Parameters:
        drop_off : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setDropOff`
        """
        pass
    def setEndDistance(self, which_region, end_distance):
        """
        Sets the value of the appropriate decay region end distance attribute of a light node.
        
        Parameters:
        which_region : 'SpotLight.MDecayRegion'
            the decay region whose end distance is to be set.
        
            values: 'first', 'second', 'third'
        end_distance : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setEndDistance`
        """
        pass
    def setLeftBarnDoorAngle(self, val='True', **kwargs):
        """
        Angle of the left of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def setPenumbra(self, penumbra_angle):
        """
        Sets the value of the "penumbraAngle" attribute of a light node.
        
        Parameters:
        penumbra_angle : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setPenumbraAngle`
        """
        pass
    def setRightBarnDoorAngle(self, val='True', **kwargs):
        """
        Angle of the right of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def setStartDistance(self, which_region, start_distance):
        """
        Sets the value of the appropriate decay region start distance attribute of a light node.
        
        Parameters:
        which_region : 'SpotLight.MDecayRegion'
            the decay region whose start distance is to be set.
        
            values: 'first', 'second', 'third'
        start_distance : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setStartDistance`
        """
        pass
    def setTopBarnDoorAngle(self, val='True', **kwargs):
        """
        Angle of the top of the barn door.                  
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    def setUseDecayRegions(self, use_decay_regions):
        """
        Sets the value of the "useDecayRegions" attribute of a light node.
        
        Parameters:
        use_decay_regions : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnSpotLight.setUseDecayRegions`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        TlightCmd is the base class for other light commands. TnonAmbientLightCmd is a
        class that looks like a command but is not.  It is a base class for the
        extended/nonExtended lights. TnonExtendedLightCmd is a base class and not a real
        command. It is inherited by several lights: TpointLight, TdirectionalLight,
        TspotLight etc. The spotLight command is used to edit the parameters of existing
        spotLights, or to create new ones. The default behaviour is to create a new
        spotlight.
        
        Flags:
        - barnDoors : bd                 (bool)          [create,query,edit]
            Are the barn doors enabled?
        
        - bottomBarnDoorAngle : bbd      (float)         [create,query,edit]
            Angle of the bottom of the barn door.
        
        - coneAngle : ca                 (float)         [create,query,edit]
            angle of the spotLight
        
        - decayRate : d                  (int)           [create]
            Decay rate of the light (0-no decay, 1-slow, 2-realistic, 3-fast)
        
        - discRadius : drs               (float)         [create,query]
            Radius of shadow disc.
        
        - dropOff : do                   (float)         [create,query,edit]
            dropOff of the spotLight
        
        - exclusive : exc                (bool)          [create,query]
            True if the light is exclusively assigned
        
        - intensity : i                  (float)         [create,query]
            Intensity of the light
        
        - leftBarnDoorAngle : lbd        (float)         [create,query,edit]
            Angle of the left of the barn door.
        
        - name : n                       (unicode)       [create,query]
            Name of the light
        
        - penumbra : p                   (float)         [create,query,edit]
            specify penumbra region
        
        - position : pos                 (float, float, float) [create,query]
            Position of the light
        
        - rgb : rgb                      (float, float, float) [create,query]
            RGB colour of the light
        
        - rightBarnDoorAngle : rbd       (float)         [create,query,edit]
            Angle of the right of the barn door.
        
        - rotation : rot                 (float, float, float) [create,query]
            Rotation of the light for orientation, where applicable
        
        - shadowColor : sc               (float, float, float) [create,query]
            Color of the light's shadow
        
        - shadowDither : sd              (float)         [create,query]
            Shadow dithering value.
        
        - shadowSamples : sh             (int)           [create,query]
            Numbr of shadow samples to use
        
        - softShadow : ss                (bool)          [create,query]
            True if soft shadowing is to be enabled
        
        - topBarnDoorAngle : tbd         (float)         [create,query,edit]
            Angle of the top of the barn door.
        
        - useRayTraceShadows : rs        (bool)          [create,query]
            True if ray trace shadows are to be used                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.spotLight`
        """
        pass
    MBarnDoor = {}
    
    
    MDecayRegion = {}
    
    
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class PointLight(NonExtendedLightShapeNode):
    def getDiscRadius(self, **kwargs):
        """
        radius of the disc around the light                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def getExclusive(self, **kwargs):
        """
        This flag is obsolete.                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def getRgb(self, **kwargs):
        """
        color of the light (0-1)                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def getShadowDither(self, **kwargs):
        """
        dither the shadow                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def getShadowSamples(self, **kwargs):
        """
        number of shadow samples.                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def getSoftShadow(self, **kwargs):
        """
        soft shadow                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def setDiscRadius(self, val='True', **kwargs):
        """
        radius of the disc around the light                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def setExclusive(self, val='True', **kwargs):
        """
        This flag is obsolete.                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def setRgb(self, val='True', **kwargs):
        """
        color of the light (0-1)                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def setShadowDither(self, val='True', **kwargs):
        """
        dither the shadow                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def setShadowSamples(self, val='True', **kwargs):
        """
        number of shadow samples.                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    def setSoftShadow(self, val='True', **kwargs):
        """
        soft shadow                  
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The pointLight command is used to edit the parameters of existing pointLights,
        or to create new ones. The default behaviour is to create a new pointlight.
        
        Flags:
        - decayRate : d                  (int)           [create,query,edit]
            decay rate of the light (0-no decay, 1-slow, 2-realistic, 3-fast)
        
        - discRadius : drs               (float)         [create,query,edit]
            radius of the disc around the light
        
        - exclusive : exc                (bool)          [create,query,edit]
            This flag is obsolete.
        
        - intensity : i                  (float)         [create,query,edit]
            intensity of the light (expressed as a percentage)
        
        - name : n                       (unicode)       [create,query,edit]
            specify the name of the light
        
        - position : pos                 (float, float, float) [create,query,edit]
            This flag is obsolete.
        
        - rgb : rgb                      (float, float, float) [create,query,edit]
            color of the light (0-1)
        
        - rotation : rot                 (float, float, float) [create,query,edit]
            This flag is obsolete.
        
        - shadowColor : sc               (float, float, float) [create,query,edit]
            the shadow color
        
        - shadowDither : sd              (float)         [create,query,edit]
            dither the shadow
        
        - shadowSamples : sh             (int)           [create,query,edit]
            number of shadow samples.
        
        - softShadow : ss                (bool)          [create,query,edit]
            soft shadow
        
        - useRayTraceShadows : rs        (bool)          [create,query,edit]
            ray trace shadows                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.pointLight`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiVolume(THsurfaceShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GpuCache(THsurfaceShape):
    """
    class counterpart of mel function `gpuCache`
    """
    
    
    
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Flags:
        - allDagObjects : ado            (bool)          []
        
        - animTimeRange : atr            (bool)          []
        
        - clashOption : clo              (unicode)       []
        
        - compressLevel : cl             (int)           []
        
        - dataFormat : df                (unicode)       []
        
        - directory : dir                (unicode)       []
        
        - dumpHierarchy : dh             (unicode)       []
        
        - endTime : et                   (time)          []
        
        - fileName : f                   (unicode)       []
        
        - filePrefix : fp                (unicode)       []
        
        - gpuDriverVersion : gdv         (bool)          []
        
        - gpuManufacturer : gma          (bool)          []
        
        - gpuMemorySize : gms            (bool)          []
        
        - gpuModel : gmo                 (bool)          []
        
        - listFileEntries : lfe          (bool)          []
        
        - listShapeEntries : lse         (bool)          []
        
        - optimizationThreshold : ot     (int)           []
        
        - optimize : o                   (bool)          []
        
        - optimizeAnimationsForMotionBlur : omb (bool)          []
        
        - prompt : p                     (bool)          []
        
        - refresh : r                    (bool)          []
        
        - refreshAll : ra                (bool)          []
        
        - refreshSettings : rs           (bool)          []
        
        - sampleMultiplier : spm         (int)           []
        
        - saveMultipleFiles : smf        (bool)          []
        
        - showFailed : sf                (bool)          []
        
        - showGlobalStats : sgs          (bool)          []
        
        - showStats : ss                 (bool)          []
        
        - simulationRate : smr           (time)          []
        
        - startTime : st                 (time)          []
        
        - useBaseTessellation : ubt      (bool)          []
        
        - waitForBackgroundReading : wbr (bool)          []
        
        - writeMaterials : wm            (bool)          []
        
        - writeUVs : wuv                 (bool)          []
        
        
        Derived from mel command `maya.cmds.gpuCache`
        """
        pass
    __apicls__ = None
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = []
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class BifrostShape(THsurfaceShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class AiStandIn(THsurfaceShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class GreasePlaneRenderShape(Mesh):
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmPatch(THsurfaceShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmGuide(THsurfaceShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FluidTexture3D(FluidShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class VolumeLight(PointLight):
    def getArc(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.arc`
        """
        pass
    def getConeEndRadius(self):
        """
        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.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.coneEndRadius`
        """
        pass
    def getEmitAmbient(self):
        """
        Retrieves the value of the "emitAmbient" attribute.
        
        Returns:
        'bool'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.emitAmbient`
        """
        pass
    def getLightShape(self):
        """
        Retrieves the "lightShape" attribute of the light. The shape can be one of the following.
        
        Returns:
        'VolumeLight.MLightShape'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.lightShape`
        """
        pass
    def getShadowAngle(self):
        """
        Retrieves the value of the "shadowAngle" attribute of a volume light node. This attribute represents an angular divergence from the direction vector of the light used to calculate soft shadows. It's enabled only if the volume light direction is kDownAxis.
        
        Returns:
        'float'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.shadowAngle`
        """
        pass
    def getVolumeLightDirection(self):
        """
        Retrieves the value of the "volumeLightDirection" attribute.
        
        Returns:
        'VolumeLight.MLightDirection'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.volumeLightDirection`
        """
        pass
    def setArc(self, arc):
        """
        Sets the value of the "arc" attribute of a volume light node.
        
        Parameters:
        arc : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.setArc`
        """
        pass
    def setConeEndRadius(self, cone_end_radius):
        """
        Sets the value of the "coneEndRadius" attribute of a volume light node.
        
        Parameters:
        cone_end_radius : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.setConeEndRadius`
        """
        pass
    def setEmitAmbient(self, emit_ambient):
        """
        Sets the value of the "emitAmbient" attribute of a volume light node.
        
        Parameters:
        emit_ambient : 'bool'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.setEmitAmbient`
        """
        pass
    def setLightShape(self, light_shape):
        """
        Sets the value of the "lightShape" attribute of a volume light node. The shape can be one of the following:
        
        Parameters:
        light_shape : 'VolumeLight.MLightShape'
            value to which the attribute will be set.
        
            values: 'boxVolume', 'sphereVolume', 'cylinderVolume', 'coneVolume'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.setLightShape`
        """
        pass
    def setShadowAngle(self, shadow_angle):
        """
        Sets the value of the "shadowAngle" attribute of a volume light node. It's enabled only if the volume light direction is kDownAxis.
        
        Parameters:
        shadow_angle : 'float'
            value to which the attribute will be set.
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.setShadowAngle`
        """
        pass
    def setVolumeLightDirection(self, volume_light_direction):
        """
        Sets the value of the "volumeLightDirection" attribute of a volume light node. The shape can be one of the following.
        
        Parameters:
        volume_light_direction : 'VolumeLight.MLightDirection'
            value to which the attribute will be set.
        
            values: 'outward', 'inward', 'downAxis'
        
        Derived from api method `maya.OpenMaya.MFnVolumeLight.setVolumeLightDirection`
        """
        pass
    MLightDirection = {}
    
    
    MLightShape = {}
    
    
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmDescription(THsurfaceShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class FluidTexture2D(FluidShape):
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmSplineDescription(THsurfaceShape):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmCardGuide(XgmGuide):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmSplineGuide(XgmGuide):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmSphereGuide(XgmGuide):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmSubdPatch(XgmPatch):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmArchiveGuide(XgmGuide):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}


class XgmNurbsPatch(XgmPatch):
    __apicls__ = None
    
    
    __melnode__ = []
    
    
    __readonly__ = {}




def _addTypeNames(): pass
def _wrappedFunc(self, *args, **kwargs):
    """
    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.
    
    Returns:
    'int'
    
    Derived from api method `maya.OpenMaya.MFnMesh.numUVs`
    """
    pass
def _about(*args, **kwargs): pass
def _makeApiMethodWrapForEmptyMesh(apiMethodName, baseMethodName='None', resultName='None', defaultVal='0'): pass


pymelTypeNameToMayaTypeName = {}

_logger = None

_lazyGlobals = {}

_pymel_options = {}

_apiMethodName = 'numUVs'

mayaTypeNameToPymelTypeName = {}


