"""Autogenerated by Shawn Frueh
Modo 15.1.2: 651188
"""


class AudioAnim:
    """AudioAnim"""
    def __init__(self):
        pass

    def Audio(self):
        """Audio object = Audio()
        
        Returns:
            object (Audio):
        """
        pass

    def End(self):
        """float = End()
        
        Returns:
            float
        """
        pass

    def Item(self):
        """Item object = Item()
        
        Returns:
            object (lxu.object.Item):
        """
        pass

    def ItemAudio(self, obj):
        """Unknown object = ItemAudio(object obj)
        
        Args:
            obj (obj):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ItemSample(self, obj, loop, time, type, value):
        """ItemSample(object obj,integer loop,float time,integer type,pointer value)
        
        Args:
            obj (obj):
            loop (int):
            time (float):
            type (int):
            value (int):

        Returns:
            None
        """
        pass

    def Loop(self):
        """integer = Loop()
        
        Returns:
            int
        """
        pass

    def Mute(self):
        """integer = Mute()
        
        Returns:
            int
        """
        pass

    def Playing(self):
        """integer = Playing()
        
        Returns:
            int
        """
        pass

    def Preview(self, startTime, endTime):
        """Audio object = Preview(float startTime,float endTime)
        
        Args:
            startTime (float):
            endTime (float):

        Returns:
            object (Audio):
        """
        pass

    def Sample(self, time, type, value):
        """Sample(float time,integer type,data[] value)
        
        Args:
            time (float):
            type (int):
            value (data[]):

        Returns:
            None
        """
        pass

    def Scrub(self):
        """integer = Scrub()
        
        Returns:
            int
        """
        pass

    def Start(self):
        """float = Start()
        
        Returns:
            float
        """
        pass


class Cache:
    """Cache"""
    def __init__(self):
        pass

    def GetData(self, name, key):
        """Unknown object = GetData(string name,integer key)
        
        Args:
            name (str):
            key (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def PurgeData(self, name):
        """PurgeData(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass

    def Register(self, name):
        """Register(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass

    def Release(self, name):
        """Release(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SetData(self, name, key, data):
        """SetData(string name,integer key,object data)
        
        Args:
            name (str):
            key (int):
            data (data):

        Returns:
            None
        """
        pass


class ChannelUI:
    """ChannelUI"""
    def __init__(self):
        pass

    def ChannelDescription(self, item, channel):
        """string desc = ChannelDescription(object item,integer channel)
        
        Args:
            item (lxu.object.Item):
            channel (int):

        Returns:
            desc (str):
        """
        pass

    def ChannelToolTip(self, item, channel):
        """string tip = ChannelToolTip(object item,integer channel)
        
        Args:
            item (lxu.object.Item):
            channel (int):

        Returns:
            tip (str):
        """
        pass

    def ChannelUserName(self, item, channel):
        """string = ChannelUserName(object item,integer channel)
        
        Args:
            item (lxu.object.Item):
            channel (int):

        Returns:
            str
        """
        pass

    def ItemTypeDesc(self, typeID, useSuper):
        """string name = ItemTypeDesc(integer typeID,integer useSuper)
        
        Args:
            typeID (int):
            useSuper (int):

        Returns:
            name (str):
        """
        pass

    def ItemTypeIconText(self, typeID, useSuper):
        """string = ItemTypeIconText(integer typeID,integer useSuper)
        
        Args:
            typeID (int):
            useSuper (int):

        Returns:
            str
        """
        pass

    def ItemTypeName(self, typeID, useSuper):
        """string name = ItemTypeName(integer typeID,integer useSuper)
        
        Args:
            typeID (int):
            useSuper (int):

        Returns:
            name (str):
        """
        pass

    def MeshMapUserName(self, name, addIcon):
        """string = MeshMapUserName(string name,integer addIcon)
        
        Args:
            name (str):
            addIcon (int):

        Returns:
            str
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class ColorMapping:
    """ColorMapping"""
    def __init__(self):
        pass

    def ConfigCount(self):
        """integer = ConfigCount()
        
        Returns:
            int
        """
        pass

    def ConfigFullPath(self, index):
        """string configPath = ConfigFullPath(integer index)
        
        Args:
            index (int):

        Returns:
            configPath (str):
        """
        pass

    def ConfigName(self, index):
        """string configName = ConfigName(integer index)
        
        Args:
            index (int):

        Returns:
            configName (str):
        """
        pass

    def GetDisplayColorMapping(self):
        """ColorMapping object = GetDisplayColorMapping()
        
        Returns:
            object (ColorMapping):
        """
        pass

    def GetNumericColorMapping(self):
        """ColorMapping object = GetNumericColorMapping()
        
        Returns:
            object (ColorMapping):
        """
        pass

    def MakeColorMapping(self, colorspaceName, toLinear):
        """ColorMapping object = MakeColorMapping(string colorspaceName,integer toLinear)
        
        Args:
            colorspaceName (str):
            toLinear (int):

        Returns:
            object (ColorMapping):
        """
        pass

    def RegisterColorspaceForConfig(self, configName, colorspaceName):
        """RegisterColorspaceForConfig(string configName,string colorspaceName)
        
        Args:
            configName (str):
            colorspaceName (str):

        Returns:
            None
        """
        pass


class Command:
    """Command"""
    def __init__(self):
        pass

    def AliasCreate(self, name, targetCmd, targetTag, targetName, args):
        """AliasCreate(string name,object targetCmd,integer targetTag,string targetName,string args)
        
        Args:
            name (str):
            targetCmd (targetCmd):
            targetTag (int):
            targetName (str):
            args (str):

        Returns:
            None
        """
        pass

    def AliasDelete(self, alias, tag, name):
        """AliasDelete(object alias,integer tag,string name)
        
        Args:
            alias (alias):
            tag (int):
            name (str):

        Returns:
            None
        """
        pass

    def AllocateUIHintsFromCommand(self, cmd, argIndex):
        """UIHints object = AllocateUIHintsFromCommand(object cmd,integer argIndex)
        
        Args:
            cmd (cmd):
            argIndex (int):

        Returns:
            object (UIHints):
        """
        pass

    def ArgsAsString(self, cmd, includeCmd):
        """string = ArgsAsString(object cmd,integer includeCmd)
        
        Args:
            cmd (cmd):
            includeCmd (int):

        Returns:
            str
        """
        pass

    def ArgsAsStringLen(self, cmd, includeCmd):
        """string = ArgsAsStringLen(object cmd,integer includeCmd)
        
        Args:
            cmd (cmd):
            includeCmd (int):

        Returns:
            str
        """
        pass

    def ArgsAsStringWithOptions(self, cmd, options):
        """string = ArgsAsStringWithOptions(object cmd,integer options)
        
        Args:
            cmd (cmd):
            options (int):

        Returns:
            str
        """
        pass

    def BlockBegin(self, name, flags):
        """BlockBegin(string name,integer flags)
        
        Args:
            name (str):
            flags (int):

        Returns:
            None
        """
        pass

    def BlockEnd(self):
        """BlockEnd()
        
        Returns:
            None
        """
        pass

    def CancelDoAtEndOfRootLevelUndoableCommand(self, visitor):
        """CancelDoAtEndOfRootLevelUndoableCommand(object visitor)
        
        Args:
            visitor (visitor):

        Returns:
            None
        """
        pass

    def CommandByIndex(self, index):
        """Command object = CommandByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (Command):
        """
        pass

    def CommandCount(self):
        """integer count = CommandCount()
        
        Returns:
            count (int):
        """
        pass

    def CreateQueryObject(self, typeName):
        """ValueArray object = CreateQueryObject(string typeName)
        
        Args:
            typeName (str):

        Returns:
            object (ValueArray):
        """
        pass

    def CurrentExecDepth(self):
        """integer depth = CurrentExecDepth()
        
        Returns:
            depth (int):
        """
        pass

    def CurrentExecIsRoot(self, ignoreBlocks):
        """CurrentExecIsRoot(integer ignoreBlocks)
        
        Args:
            ignoreBlocks (int):

        Returns:
            None
        """
        pass

    def DoAtEndOfRootLevelUndoableCommand(self, visitor):
        """DoAtEndOfRootLevelUndoableCommand(object visitor)
        
        Args:
            visitor (visitor):

        Returns:
            None
        """
        pass

    def ExecEntryAsArgString(self, index):
        """string = ExecEntryAsArgString(integer index)
        
        Args:
            index (int):

        Returns:
            str
        """
        pass

    def ExecEntryName(self, index):
        """string name = ExecEntryName(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def ExecEntryType(self, index):
        """integer type = ExecEntryType(integer index)
        
        Args:
            index (int):

        Returns:
            type (int):
        """
        pass

    def ExecEntryUserName(self, index):
        """string userName = ExecEntryUserName(integer index)
        
        Args:
            index (int):

        Returns:
            userName (str):
        """
        pass

    def ExecFlagsAsPrefixString(self, flags):
        """string = ExecFlagsAsPrefixString(integer flags)
        
        Args:
            flags (int):

        Returns:
            str
        """
        pass

    def ExecuteArgString(self, execFlags, tag, args):
        """ExecuteArgString(integer execFlags,integer tag,string args)
        
        Args:
            execFlags (int):
            tag (int):
            args (str):

        Returns:
            None
        """
        pass

    def ExecuteArgString2(self, execFlags, tag, args):
        """Command object = ExecuteArgString2(integer execFlags,integer tag,string args)
        
        Args:
            execFlags (int):
            tag (int):
            args (str):

        Returns:
            object (Command):
        """
        pass

    def ExecuteAttribObject(self, execFlags, tag, cmdName, attribArgs):
        """ExecuteAttribObject(integer execFlags,integer tag,string cmdName,object attribArgs)
        
        Args:
            execFlags (int):
            tag (int):
            cmdName (str):
            attribArgs (attribArgs):

        Returns:
            None
        """
        pass

    def ExecuteAttribObject2(self, execFlags, tag, cmdName, attribArgs):
        """Command object = ExecuteAttribObject2(integer execFlags,integer tag,string cmdName,object attribArgs)
        
        Args:
            execFlags (int):
            tag (int):
            cmdName (str):
            attribArgs (attribArgs):

        Returns:
            object (Command):
        """
        pass

    def ExecuteBooleanArgString(self, execFlags, tag, args):
        """ExecuteBooleanArgString(integer execFlags,integer tag,string args)
        
        Args:
            execFlags (int):
            tag (int):
            args (str):

        Returns:
            None
        """
        pass

    def ExecuteBooleanArgString2(self, execFlags, tag, args):
        """Command object = ExecuteBooleanArgString2(integer execFlags,integer tag,string args)
        
        Args:
            execFlags (int):
            tag (int):
            args (str):

        Returns:
            object (Command):
        """
        pass

    def ExecuteImplicitScript(self, definition, execFlags):
        """ExecuteImplicitScript(string definition,integer execFlags)
        
        Args:
            definition (str):
            execFlags (int):

        Returns:
            None
        """
        pass

    def ExecuteImplicitScript2(self, definition, execFlags):
        """Command object = ExecuteImplicitScript2(string definition,integer execFlags)
        
        Args:
            definition (str):
            execFlags (int):

        Returns:
            object (Command):
        """
        pass

    def ExecuteSpecial(self, execFlags, cmd, specialArgIndex):
        """ExecuteSpecial(integer execFlags,object cmd,integer specialArgIndex)
        
        Args:
            execFlags (int):
            cmd (cmd):
            specialArgIndex (int):

        Returns:
            None
        """
        pass

    def ExecuteToggleArgString(self, execFlags, tag, args, newState):
        """ExecuteToggleArgString(integer execFlags,integer tag,string args,integer newState)
        
        Args:
            execFlags (int):
            tag (int):
            args (str):
            newState (int):

        Returns:
            None
        """
        pass

    def ExecuteToggleArgString2(self, execFlags, tag, args, newState):
        """Command object = ExecuteToggleArgString2(integer execFlags,integer tag,string args,integer newState)
        
        Args:
            execFlags (int):
            tag (int):
            args (str):
            newState (int):

        Returns:
            object (Command):
        """
        pass

    def GetNameSep(self):
        """integer sep = GetNameSep()
        
        Returns:
            sep (int):
        """
        pass

    def GetToggleArgState(self, cmd):
        """(integer state,Value object) = GetToggleArgState(object cmd)
        
        Args:
            cmd (cmd):

        Returns:
            (integer state,Value object)
        """
        pass

    def IsAliased(self, cmd):
        """boolean = IsAliased(object cmd)
        
        Args:
            cmd (cmd):

        Returns:
            bool
        """
        pass

    def IsBooleanArgString(self, string):
        """boolean = IsBooleanArgString(string string)
        
        Args:
            string (str):

        Returns:
            bool
        """
        pass

    def IsContainer(self, cmd):
        """boolean = IsContainer(object cmd)
        
        Args:
            cmd (cmd):

        Returns:
            bool
        """
        pass

    def IsGlobalInteractionOK(self):
        """boolean = IsGlobalInteractionOK()
        
        Returns:
            bool
        """
        pass

    def IsImplicitScript(self, definition):
        """boolean = IsImplicitScript(string definition)
        
        Args:
            definition (str):

        Returns:
            bool
        """
        pass

    def IsToggleArgString(self, string):
        """boolean = IsToggleArgString(string string)
        
        Args:
            string (str):

        Returns:
            bool
        """
        pass

    def Lookup(self, name):
        """integer tag = Lookup(string name)
        
        Args:
            name (str):

        Returns:
            tag (int):
        """
        pass

    def MasterStatus(self):
        """integer status = MasterStatus()
        
        Returns:
            status (int):
        """
        pass

    def ParseArgString(self, cmd, alertFlags, args):
        """ParseArgString(object cmd,integer alertFlags,string args)
        
        Args:
            cmd (cmd):
            alertFlags (int):
            args (str):

        Returns:
            None
        """
        pass

    def ParseAttribObject(self, cmd, alertFlags, attribArgs):
        """ParseAttribObject(object cmd,integer alertFlags,object attribArgs)
        
        Args:
            cmd (cmd):
            alertFlags (int):
            attribArgs (attribArgs):

        Returns:
            None
        """
        pass

    def PostModeBegin(self, cmd, tag, name, args, postEndObj):
        """PostModeBegin(object cmd,integer tag,string name,string args,object postEndObj)
        
        Args:
            cmd (cmd):
            tag (int):
            name (str):
            args (str):
            postEndObj (postEndObj):

        Returns:
            None
        """
        pass

    def PostModeEnd(self):
        """PostModeEnd()
        
        Returns:
            None
        """
        pass

    def PostModeRestart(self):
        """PostModeRestart()
        
        Returns:
            None
        """
        pass

    def PostModeState(self):
        """PostModeState()
        
        Returns:
            None
        """
        pass

    def ProcessStringFlags(self, flags, string):
        """(integer newFlags,string afterFlags) = ProcessStringFlags(integer flags,string string)
        
        Args:
            flags (int):
            string (str):

        Returns:
            (integer newFlags,string afterFlags)
        """
        pass

    def Proto(self, tag, name):
        """Command object = Proto(integer tag,string name)
        
        Args:
            tag (int):
            name (str):

        Returns:
            object (Command):
        """
        pass

    def ProtoFromCommand(self, cmd):
        """Command object = ProtoFromCommand(object cmd)
        
        Args:
            cmd (cmd):

        Returns:
            object (Command):
        """
        pass

    def Query(self, cmd, index):
        """ValueArray object = Query(object cmd,integer index)
        
        Args:
            cmd (cmd):
            index (int):

        Returns:
            object (ValueArray):
        """
        pass

    def QueryArgString(self, cmd, alertFlags, args, includesCmdName):
        """(ValueArray object,integer queryIndex) = QueryArgString(object cmd,integer alertFlags,string args,integer includesCmdName)
        
        Args:
            cmd (cmd):
            alertFlags (int):
            args (str):
            includesCmdName (int):

        Returns:
            (ValueArray object,integer queryIndex)
        """
        pass

    def RefireBegin(self):
        """RefireBegin()
        
        Returns:
            None
        """
        pass

    def RefireBlock(self):
        """string name = RefireBlock()
        
        Returns:
            name (str):
        """
        pass

    def RefireCmd(self):
        """Command object = RefireCmd()
        
        Returns:
            object (Command):
        """
        pass

    def RefireEnd(self):
        """RefireEnd()
        
        Returns:
            None
        """
        pass

    def RefireState(self):
        """integer state = RefireState()
        
        Returns:
            state (int):
        """
        pass

    def SandboxAddObject(self, object):
        """SandboxAddObject(object object)
        
        Args:
            object (object):

        Returns:
            None
        """
        pass

    def SandboxBegin(self, flags):
        """SandboxBegin(integer flags)
        
        Args:
            flags (int):

        Returns:
            None
        """
        pass

    def SandboxEnd(self):
        """SandboxEnd()
        
        Returns:
            None
        """
        pass

    def SandboxFlags(self):
        """integer flags = SandboxFlags()
        
        Returns:
            flags (int):
        """
        pass

    def SandboxObjectByCommand(self, cmd):
        """Unknown object = SandboxObjectByCommand(object cmd)
        
        Args:
            cmd (cmd):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SandboxObjectByIndex(self, index):
        """Unknown object = SandboxObjectByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SandboxObjectCount(self):
        """integer count = SandboxObjectCount()
        
        Returns:
            count (int):
        """
        pass

    def SandboxObjectLookup(self, guid):
        """Unknown object = SandboxObjectLookup(string guid)
        
        Args:
            guid (str):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SandboxState(self):
        """SandboxState()
        
        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SetIsGlobalInteractionOK(self, isOK):
        """SetIsGlobalInteractionOK(integer isOK)
        
        Args:
            isOK (int):

        Returns:
            None
        """
        pass

    def SetNameSep(self, sep):
        """SetNameSep(integer sep)
        
        Args:
            sep (int):

        Returns:
            None
        """
        pass

    def SetToggleArgState(self, cmd, state):
        """SetToggleArgState(object cmd,integer state)
        
        Args:
            cmd (cmd):
            state (int):

        Returns:
            None
        """
        pass

    def Spawn(self, tag, name):
        """Command object = Spawn(integer tag,string name)
        
        Args:
            tag (int):
            name (str):

        Returns:
            object (Command):
        """
        pass

    def SpawnFromCommand(self, cmd):
        """Command object = SpawnFromCommand(object cmd)
        
        Args:
            cmd (cmd):

        Returns:
            object (Command):
        """
        pass

    def SpawnFromString(self, args):
        """(integer execFlags,integer queryArgIndex,Command object) = SpawnFromString(string args)
        
        Args:
            args (str):

        Returns:
            (integer execFlags,integer queryArgIndex,Command object)
        """
        pass

    def SpawnImplicitScript(self, definition):
        """Command object = SpawnImplicitScript(string definition)
        
        Args:
            definition (str):

        Returns:
            object (Command):
        """
        pass

    def SpawnUnaliased(self, tag, name):
        """Command object = SpawnUnaliased(integer tag,string name)
        
        Args:
            tag (int):
            name (str):

        Returns:
            object (Command):
        """
        pass

    def Usage(self, cmd):
        """string buffer = Usage(object cmd)
        
        Args:
            cmd (cmd):

        Returns:
            buffer (str):
        """
        pass


class Deformer:
    """Deformer"""
    def __init__(self):
        pass

    def DeformEltToItem(self, elt):
        """object = DeformEltToItem(id elt)
        
        Args:
            elt (id):

        Returns:
            object
        """
        pass

    def DeformerChannel(self, item):
        """integer index = DeformerChannel(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            index (int):
        """
        pass

    def DeformerDeformationItem(self, defItem):
        """item object = DeformerDeformationItem(object defItem)
        
        Args:
            defItem (defItem):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def DeformerFlags(self, item):
        """integer flags = DeformerFlags(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            flags (int):
        """
        pass

    def GroupDeformer(self, dgroup, chanRead):
        """GroupDeformer object = GroupDeformer(object dgroup,object chanRead)
        
        Args:
            dgroup (dgroup):
            chanRead (chanRead):

        Returns:
            object (GroupDeformer):
        """
        pass

    def InvalidateTargets(self, scene):
        """InvalidateTargets(object scene)
        
        Args:
            scene (scene):

        Returns:
            None
        """
        pass

    def ItemToDeformElt(self, item):
        """id = ItemToDeformElt(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            id
        """
        pass

    def MergeChangeState(self, c1, c2):
        """MergeChangeState(integer c1,integer c2)
        
        Args:
            c1 (int):
            c2 (int):

        Returns:
            None
        """
        pass

    def MeshByIndex(self, defItem, index):
        """Item object = MeshByIndex(object defItem,integer index)
        
        Args:
            defItem (defItem):
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def MeshCount(self, defItem):
        """integer count = MeshCount(object defItem)
        
        Args:
            defItem (defItem):

        Returns:
            count (int):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def StackTargetByIndex(self, defItem, index):
        """Item object = StackTargetByIndex(object defItem,integer index)
        
        Args:
            defItem (defItem):
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def StackTargetCount(self, defItem):
        """integer count = StackTargetCount(object defItem)
        
        Args:
            defItem (defItem):

        Returns:
            count (int):
        """
        pass


class DirCache:
    """DirCache"""
    def __init__(self):
        pass

    def AddClient(self):
        """AddClient()
        
        Returns:
            None
        """
        pass

    def ArePathsEqual(self, path1, path2):
        """ArePathsEqual(string path1,string path2)
        
        Args:
            path1 (str):
            path2 (str):

        Returns:
            None
        """
        pass

    def AttributesChanged(self, dirCacheEntry, which, attribute):
        """AttributesChanged(object dirCacheEntry,integer which,string attribute)
        
        Args:
            dirCacheEntry (dirCacheEntry):
            which (int):
            attribute (str):

        Returns:
            None
        """
        pass

    def CachedThumbnailAsyncCancel(self, ident):
        """CachedThumbnailAsyncCancel(string ident)
        
        Args:
            ident (str):

        Returns:
            None
        """
        pass

    def CanBeRenamed(self, path):
        """CanBeRenamed(string path)
        
        Args:
            path (str):

        Returns:
            None
        """
        pass

    def IsChildOfPath(self, possibleChild, parentToTestAgainsts, orIsSame):
        """IsChildOfPath(string possibleChild,string parentToTestAgainsts,integer orIsSame)
        
        Args:
            possibleChild (str):
            parentToTestAgainsts (str):
            orIsSame (int):

        Returns:
            None
        """
        pass

    def Lookup(self, path):
        """DirCacheEntry object = Lookup(string path)
        
        Args:
            path (str):

        Returns:
            object (DirCacheEntry):
        """
        pass

    def MakeDirHierarchy(self, path, skipLastPart):
        """MakeDirHierarchy(string path,integer skipLastPart)
        
        Args:
            path (str):
            skipLastPart (int):

        Returns:
            None
        """
        pass

    def MakeUniqueIn(self, object, filename):
        """string = MakeUniqueIn(object object,string filename)
        
        Args:
            object (object):
            filename (str):

        Returns:
            str
        """
        pass

    def ParseName(self, filename, baseName, baseNameLen, path, pathLen):
        """ParseName(string filename,byte[] baseName,integer baseNameLen,byte[] path,integer pathLen)
        
        Args:
            filename (str):
            baseName (byte[]):
            baseNameLen (int):
            path (byte[]):
            pathLen (int):

        Returns:
            None
        """
        pass

    def PathCompose(self, filename, filenameLen, baseName, path):
        """PathCompose(byte[] filename,integer filenameLen,string baseName,string path)
        
        Args:
            filename (byte[]):
            filenameLen (int):
            baseName (str):
            path (str):

        Returns:
            None
        """
        pass

    def RemoveClient(self):
        """RemoveClient()
        
        Returns:
            None
        """
        pass

    def RootByIndex(self, index):
        """DirCacheEntry object = RootByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (DirCacheEntry):
        """
        pass

    def RootCount(self):
        """integer count = RootCount()
        
        Returns:
            count (int):
        """
        pass

    def RootLock(self):
        """RootLock()
        
        Returns:
            None
        """
        pass

    def RootUnlock(self):
        """RootUnlock()
        
        Returns:
            None
        """
        pass

    def ScanForChanges(self, path):
        """ScanForChanges(string path)
        
        Args:
            path (str):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SetPosOnDrop(self, path, dest):
        """SetPosOnDrop(string path,object dest)
        
        Args:
            path (str):
            dest (dest):

        Returns:
            None
        """
        pass

    def ToLocalAlias(self, path):
        """string = ToLocalAlias(byte[] path)
        
        Args:
            path (byte[]):

        Returns:
            str
        """
        pass


class Drop:
    """Drop"""
    def __init__(self):
        pass

    def Action(self):
        """(string serverName,integer actionCode) = Action()
        
        Returns:
            (string serverName,integer actionCode)
        """
        pass

    def Destination(self):
        """Unknown object = Destination()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Source(self):
        """(string sourceType,Unknown object) = Source()
        
        Returns:
            (string sourceType,Unknown object)
        """
        pass


class File:
    """File"""
    def __init__(self):
        pass

    def AllocRedirect(self):
        """FileRedirect object = AllocRedirect()
        
        Returns:
            object (FileRedirect):
        """
        pass

    def AllocReference(self, path):
        """FileReference object = AllocReference(string path)
        
        Args:
            path (str):

        Returns:
            object (FileReference):
        """
        pass

    def ArePathsEqual(self, path1, path2):
        """boolean = ArePathsEqual(string path1,string path2)
        
        Args:
            path1 (str):
            path2 (str):

        Returns:
            bool
        """
        pass

    def ComposePath(self, basename, path):
        """string = ComposePath(string basename,string path)
        
        Args:
            basename (str):
            path (str):

        Returns:
            str
        """
        pass

    def DirDelete(self, filename):
        """DirDelete(string filename)
        
        Args:
            filename (str):

        Returns:
            None
        """
        pass

    def Execute(self, show, force32):
        """string argv = Execute(integer show,integer force32)
        
        Args:
            show (int):
            force32 (int):

        Returns:
            argv (str):
        """
        pass

    def FileCopy(self, srcFilePath, dstFilePath, overwrite):
        """FileCopy(string srcFilePath,string dstFilePath,integer overwrite)
        
        Args:
            srcFilePath (str):
            dstFilePath (str):
            overwrite (int):

        Returns:
            None
        """
        pass

    def FileDateString(self, filename):
        """string = FileDateString(string filename)
        
        Args:
            filename (str):

        Returns:
            str
        """
        pass

    def FileDelete(self, filename):
        """FileDelete(string filename)
        
        Args:
            filename (str):

        Returns:
            None
        """
        pass

    def FileFromURL(self, url):
        """string = FileFromURL(string url)
        
        Args:
            url (str):

        Returns:
            str
        """
        pass

    def FileSystemPath(self, name):
        """string path = FileSystemPath(string name)
        
        Args:
            name (str):

        Returns:
            path (str):
        """
        pass

    def FileToURL(self, filename):
        """string = FileToURL(string filename)
        
        Args:
            filename (str):

        Returns:
            str
        """
        pass

    def FindSequenceBounds(self, pattern):
        """(integer first,integer last) = FindSequenceBounds(string pattern)
        
        Args:
            pattern (str):

        Returns:
            (integer first,integer last)
        """
        pass

    def FindSequencePattern(self, filename):
        """string = FindSequencePattern(string filename)
        
        Args:
            filename (str):

        Returns:
            str
        """
        pass

    def FromLocal(self, local):
        """string = FromLocal(string local)
        
        Args:
            local (str):

        Returns:
            str
        """
        pass

    def GenerateSequenceName(self, pattern, frame):
        """string = GenerateSequenceName(string pattern,integer frame)
        
        Args:
            pattern (str):
            frame (int):

        Returns:
            str
        """
        pass

    def IsAbsolutePath(self, path):
        """boolean = IsAbsolutePath(string path)
        
        Args:
            path (str):

        Returns:
            bool
        """
        pass

    def MakeDirectory(self, path):
        """MakeDirectory(string path)
        
        Args:
            path (str):

        Returns:
            None
        """
        pass

    def MakeLegalFilename(self, filename, replaceDot):
        """MakeLegalFilename(byte[] filename,integer replaceDot)
        
        Args:
            filename (byte[]):
            replaceDot (int):

        Returns:
            None
        """
        pass

    def MakeRelative(self, filename, path):
        """string = MakeRelative(string filename,string path)
        
        Args:
            filename (str):
            path (str):

        Returns:
            str
        """
        pass

    def MakeUnique(self, filename):
        """string = MakeUnique(string filename)
        
        Args:
            filename (str):

        Returns:
            str
        """
        pass

    def OpenFileWithDefaultApp(self, filename):
        """OpenFileWithDefaultApp(string filename)
        
        Args:
            filename (str):

        Returns:
            None
        """
        pass

    def ParsePath(self, filename, component):
        """string = ParsePath(string filename,integer component)
        
        Args:
            filename (str):
            component (int):

        Returns:
            str
        """
        pass

    def RenameFile(self, from_str, to_str):
        """RenameFile(string from_str,string to_str)
        
        Args:
            from_str (str):
            to_str (str):

        Returns:
            None
        """
        pass

    def RevealInFileViewer(self, filename):
        """RevealInFileViewer(string filename)
        
        Args:
            filename (str):

        Returns:
            None
        """
        pass

    def SetExtension(self, filename, extension):
        """string = SetExtension(string filename,string extension)
        
        Args:
            filename (str):
            extension (str):

        Returns:
            str
        """
        pass

    def TestFileMode(self, filename):
        """integer mode = TestFileMode(string filename)
        
        Args:
            filename (str):

        Returns:
            mode (int):
        """
        pass

    def TestFileType(self, filename):
        """(boolean,integer type) = TestFileType(string filename)
        
        Args:
            filename (str):

        Returns:
            type) ((boolean,integer):
        """
        pass

    def ToLocal(self, neutral):
        """string = ToLocal(byte[] neutral)
        
        Args:
            neutral (byte[]):

        Returns:
            str
        """
        pass

    def ToLocalAlias(self, neutral):
        """string = ToLocalAlias(string neutral)
        
        Args:
            neutral (str):

        Returns:
            str
        """
        pass

    def ValidateLicense(self, product, versionNum):
        """ValidateLicense(string product,integer versionNum)
        
        Args:
            product (str):
            versionNum (int):

        Returns:
            None
        """
        pass


class GUID:
    """GUID"""
    def __init__(self):
        pass

    def Class(self, guid):
        """string = Class(string guid)
        
        Args:
            guid (str):

        Returns:
            str
        """
        pass

    def ClassName(self, guid):
        """string = ClassName(string guid)
        
        Args:
            guid (str):

        Returns:
            str
        """
        pass

    def Compare(self, guid1, guid2):
        """integer = Compare(string guid1,string guid2)
        
        Args:
            guid1 (str):
            guid2 (str):

        Returns:
            int
        """
        pass

    def Fixed(self, guid):
        """string = Fixed(string guid)
        
        Args:
            guid (str):

        Returns:
            str
        """
        pass

    def GetName(self, guid):
        """string = GetName(string guid)
        
        Args:
            guid (str):

        Returns:
            str
        """
        pass

    def Translate(self, guidStr):
        """string = Translate(string guidStr)
        
        Args:
            guidStr (str):

        Returns:
            str
        """
        pass


class Host:
    """Host"""
    def __init__(self):
        pass

    def AddServer(self, factory):
        """AddServer(object factory)
        
        Args:
            factory (factory):

        Returns:
            None
        """
        pass

    def DefaultPath(self):
        """string path = DefaultPath()
        
        Returns:
            path (str):
        """
        pass

    def LookupServer(self, className, name, allowLoad):
        """Factory object = LookupServer(string className,string name,integer allowLoad)
        
        Args:
            className (str):
            name (str):
            allowLoad (int):

        Returns:
            object (Factory):
        """
        pass

    def NumServers(self, className):
        """integer = NumServers(string className)
        
        Args:
            className (str):

        Returns:
            int
        """
        pass

    def SaverSave(self, filename, format, object, monitor):
        """SaverSave(string filename,string format,object object,object monitor)
        
        Args:
            filename (str):
            format (str):
            object (object):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def SaverVerify(self, format, object, msg):
        """SaverVerify(string format,object object,object msg)
        
        Args:
            format (str):
            object (object):
            msg (msg):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ServerByIndex(self, className, index):
        """Factory object = ServerByIndex(string className,integer index)
        
        Args:
            className (str):
            index (int):

        Returns:
            object (Factory):
        """
        pass

    def ServerGetIndex(self, className, name):
        """integer index = ServerGetIndex(string className,string name)
        
        Args:
            className (str):
            name (str):

        Returns:
            index (int):
        """
        pass

    def SpawnForTagsOnly(self):
        """SpawnForTagsOnly()
        
        Returns:
            None
        """
        pass

    def TestServer(self, className, name):
        """boolean = TestServer(string className,string name)
        
        Args:
            className (str):
            name (str):

        Returns:
            bool
        """
        pass

    def UpdateModule(self, name):
        """UpdateModule(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass


class IO:
    """IO"""
    def __init__(self):
        pass

    def OpenBlockStore(self, filename, format, flags):
        """(boolean,BlockStore object) = OpenBlockStore(string filename,string format,integer flags)
        
        Args:
            filename (str):
            format (str):
            flags (int):

        Returns:
            object) ((boolean,BlockStore):
        """
        pass

    def PeekOptions(self):
        """object = PeekOptions()
        
        Returns:
            object
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SetOptions(self, options):
        """SetOptions(object options)
        
        Args:
            options (options):

        Returns:
            None
        """
        pass


class Image:
    """Image"""
    def __init__(self):
        pass

    def Composite(self, dest, source, pos):
        """Composite(object dest,object source,vector pos)
        
        Args:
            dest (dest):
            source (lxu.object.Item):
            pos (tuple):

        Returns:
            None
        """
        pass

    def Create(self, width, height, type, maxIndex):
        """Image object = Create(integer width,integer height,integer type,integer maxIndex)
        
        Args:
            width (int):
            height (int):
            type (int):
            maxIndex (int):

        Returns:
            object (lx.object.Image):
        """
        pass

    def CreateCrop(self, sourceImage, x, y, w, h):
        """Image object = CreateCrop(object sourceImage,float x,float y,float w,float h)
        
        Args:
            sourceImage (sourceImage):
            x (float):
            y (float):
            w (float):
            h (float):

        Returns:
            object (lx.object.Image):
        """
        pass

    def CreateLayered(self, width, height, layerNum):
        """Unknown object = CreateLayered(integer width,integer height,integer layerNum)
        
        Args:
            width (int):
            height (int):
            layerNum (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def DrawLine(self, image, p0, p1, color):
        """DrawLine(object image,vector p0,vector p1,vector color)
        
        Args:
            image (lx.object.Image):
            p0 (tuple):
            p1 (tuple):
            color (tuple):

        Returns:
            None
        """
        pass

    def Duplicate(self, source, type):
        """Image object = Duplicate(object source,integer type)
        
        Args:
            source (lxu.object.Item):
            type (int):

        Returns:
            object (lx.object.Image):
        """
        pass

    def ImageGetBuffer(self, sourceImage, type, buf):
        """ImageGetBuffer(object sourceImage,integer type,data[] buf)
        
        Args:
            sourceImage (sourceImage):
            type (int):
            buf (data[]):

        Returns:
            None
        """
        pass

    def Kelvin2RGB(self, kelvin):
        """vector rgbColor = Kelvin2RGB(float kelvin)
        
        Args:
            kelvin (float):

        Returns:
            rgbColor (tuple):
        """
        pass

    def Load(self, filePath):
        """Image object = Load(string filePath)
        
        Args:
            filePath (str):

        Returns:
            object (lx.object.Image):
        """
        pass

    def LoadNoCache(self, filePath):
        """Image object = LoadNoCache(string filePath)
        
        Args:
            filePath (str):

        Returns:
            object (lx.object.Image):
        """
        pass

    def RGB2Kelvin(self, rgbColor):
        """float kelvin = RGB2Kelvin(vector rgbColor)
        
        Args:
            rgbColor (tuple):

        Returns:
            kelvin (float):
        """
        pass

    def Resample(self, dest, source, hint):
        """Resample(object dest,object source,integer hint)
        
        Args:
            dest (dest):
            source (lxu.object.Item):
            hint (int):

        Returns:
            None
        """
        pass

    def Save(self, image, filePath, format, monitor):
        """Save(object image,string filePath,string format,object monitor)
        
        Args:
            image (lx.object.Image):
            filePath (str):
            format (str):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def SaveLayered(self, layeredImage, filePath, format, monitor):
        """SaveLayered(object layeredImage,string filePath,string format,object monitor)
        
        Args:
            layeredImage (layeredImage):
            filePath (str):
            format (str):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class ImageMonitor:
    """ImageMonitor"""
    def __init__(self):
        pass

    def RefreshViews(self, imageSource, immediate):
        """RefreshViews(string imageSource,integer immediate)
        
        Args:
            imageSource (str):
            immediate (int):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ServerByIndex(self, index):
        """ImageMonitor object = ServerByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (ImageMonitor):
        """
        pass

    def ServerCount(self):
        """integer count = ServerCount()
        
        Returns:
            count (int):
        """
        pass

    def ServerLookup(self, name):
        """ImageMonitor object = ServerLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (ImageMonitor):
        """
        pass

    def ServerNameByIndex(self, index):
        """string name = ServerNameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def ServerUserNameByIndex(self, index):
        """string name = ServerUserNameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def SetImage(self, imageSource, image, frameBuffer, bufferIndex, x1, y1, x2, y2, imageProc, processedThumbnail):
        """SetImage(string imageSource,object image,object frameBuffer,integer bufferIndex,float x1,float y1,float x2,float y2,object imageProc,object processedThumbnail)
        
        Args:
            imageSource (str):
            image (lx.object.Image):
            frameBuffer (frameBuffer):
            bufferIndex (int):
            x1 (float):
            y1 (float):
            x2 (float):
            y2 (float):
            imageProc (imageProc):
            processedThumbnail (processedThumbnail):

        Returns:
            None
        """
        pass

    def SourceCount(self):
        """integer count = SourceCount()
        
        Returns:
            count (int):
        """
        pass

    def SourceNameByIndex(self, index):
        """string name = SourceNameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def SourceUserNameByIndex(self, index):
        """string username = SourceUserNameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            username (str):
        """
        pass


class ImageProcessing:
    """ImageProcessing"""
    def __init__(self):
        pass

    def Create(self):
        """ImageProcessing object = Create()
        
        Returns:
            object (ImageProcessing):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class InputMap:
    """InputMap"""
    def __init__(self):
        pass

    def CanEventsCoexist(self, im, event1, event2):
        """CanEventsCoexist(id im,integer event1,integer event2)
        
        Args:
            im (id):
            event1 (int):
            event2 (int):

        Returns:
            None
        """
        pass

    def ContextCount(self):
        """integer count = ContextCount()
        
        Returns:
            count (int):
        """
        pass

    def DefineClientTests(self, tester):
        """DefineClientTests(object tester)
        
        Args:
            tester (tester):

        Returns:
            None
        """
        pass

    def DefineCustomEvent(self, event, name, flags):
        """DefineCustomEvent(integer event,string name,integer flags)
        
        Args:
            event (int):
            name (str):
            flags (int):

        Returns:
            None
        """
        pass

    def DefineGroup(self, group):
        """DefineGroup(string group)
        
        Args:
            group (str):

        Returns:
            None
        """
        pass

    def DefineRegion(self, event, name):
        """DefineRegion(integer event,string name)
        
        Args:
            event (int):
            name (str):

        Returns:
            None
        """
        pass

    def DefineStandardEvent(self, event, flags):
        """DefineStandardEvent(integer event,integer flags)
        
        Args:
            event (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Desc(self, im):
        """string desc = Desc(id im)
        
        Args:
            im (id):

        Returns:
            desc (str):
        """
        pass

    def EventCount(self, im):
        """integer count = EventCount(id im)
        
        Args:
            im (id):

        Returns:
            count (int):
        """
        pass

    def EventDesc(self, im, stateName, name, index):
        """string desc = EventDesc(id im,string stateName,string name,integer index)
        
        Args:
            im (id):
            stateName (str):
            name (str):
            index (int):

        Returns:
            desc (str):
        """
        pass

    def EventFlags(self, im, index):
        """integer flags = EventFlags(id im,integer index)
        
        Args:
            im (id):
            index (int):

        Returns:
            flags (int):
        """
        pass

    def EventHelpURL(self, im, stateName, name, index):
        """string helpURL = EventHelpURL(id im,string stateName,string name,integer index)
        
        Args:
            im (id):
            stateName (str):
            name (str):
            index (int):

        Returns:
            helpURL (str):
        """
        pass

    def EventName(self, im, index):
        """string name = EventName(id im,integer index)
        
        Args:
            im (id):
            index (int):

        Returns:
            name (str):
        """
        pass

    def EventType(self, im, index):
        """integer type = EventType(id im,integer index)
        
        Args:
            im (id):
            index (int):

        Returns:
            type (int):
        """
        pass

    def EventUserName(self, im, stateName, name, index):
        """string username = EventUserName(id im,string stateName,string name,integer index)
        
        Args:
            im (id):
            stateName (str):
            name (str):
            index (int):

        Returns:
            username (str):
        """
        pass

    def FindEvent(self, im, name, type):
        """integer index = FindEvent(id im,string name,integer type)
        
        Args:
            im (id):
            name (str):
            type (int):

        Returns:
            index (int):
        """
        pass

    def FindRegion(self, im, name, type):
        """integer index = FindRegion(id im,string name,integer type)
        
        Args:
            im (id):
            name (str):
            type (int):

        Returns:
            index (int):
        """
        pass

    def GetMouseMap(self, im):
        """Unknown object = GetMouseMap(id im)
        
        Args:
            im (id):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def GroupUserName(self, path, depth):
        """string username = GroupUserName(string path,integer depth)
        
        Args:
            path (str):
            depth (int):

        Returns:
            username (str):
        """
        pass

    def HelpURL(self, im):
        """string helpURL = HelpURL(id im)
        
        Args:
            im (id):

        Returns:
            helpURL (str):
        """
        pass

    def Name(self, im):
        """string name = Name(id im)
        
        Args:
            im (id):

        Returns:
            name (str):
        """
        pass

    def RefreshContexts(self):
        """RefreshContexts()
        
        Returns:
            None
        """
        pass

    def RefreshStates(self, flags):
        """RefreshStates(integer flags)
        
        Args:
            flags (int):

        Returns:
            None
        """
        pass

    def RegionCount(self, im):
        """integer count = RegionCount(id im)
        
        Args:
            im (id):

        Returns:
            count (int):
        """
        pass

    def RegionDesc(self, im, stateName, name, index):
        """string desc = RegionDesc(id im,string stateName,string name,integer index)
        
        Args:
            im (id):
            stateName (str):
            name (str):
            index (int):

        Returns:
            desc (str):
        """
        pass

    def RegionHelpURL(self, im, stateName, name, index):
        """string helpURL = RegionHelpURL(id im,string stateName,string name,integer index)
        
        Args:
            im (id):
            stateName (str):
            name (str):
            index (int):

        Returns:
            helpURL (str):
        """
        pass

    def RegionName(self, im, i):
        """string name = RegionName(id im,integer i)
        
        Args:
            im (id):
            i (int):

        Returns:
            name (str):
        """
        pass

    def RegionType(self, im, i):
        """integer type = RegionType(id im,integer i)
        
        Args:
            im (id):
            i (int):

        Returns:
            type (int):
        """
        pass

    def RegionUserName(self, im, stateName, name, index):
        """string username = RegionUserName(id im,string stateName,string name,integer index)
        
        Args:
            im (id):
            stateName (str):
            name (str):
            index (int):

        Returns:
            username (str):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def StandardEventFlags(self, event):
        """integer flags = StandardEventFlags(integer event)
        
        Args:
            event (int):

        Returns:
            flags (int):
        """
        pass

    def StandardEventName(self, event):
        """string name = StandardEventName(integer event)
        
        Args:
            event (int):

        Returns:
            name (str):
        """
        pass

    def StateCatUserName(self, cat):
        """string name = StateCatUserName(string cat)
        
        Args:
            cat (str):

        Returns:
            name (str):
        """
        pass

    def StateCount(self, im):
        """integer count = StateCount(id im)
        
        Args:
            im (id):

        Returns:
            count (int):
        """
        pass

    def StateUIFallbacksCount(self, stateName):
        """integer count = StateUIFallbacksCount(string stateName)
        
        Args:
            stateName (str):

        Returns:
            count (int):
        """
        pass

    def StateUIFallbacksName(self, stateName, index):
        """string name = StateUIFallbacksName(string stateName,integer index)
        
        Args:
            stateName (str):
            index (int):

        Returns:
            name (str):
        """
        pass

    def StateUIListCatCount(self):
        """integer count = StateUIListCatCount()
        
        Returns:
            count (int):
        """
        pass

    def StateUIListCatName(self, index):
        """string name = StateUIListCatName(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def StateUIListCount(self, cat):
        """integer count = StateUIListCount(string cat)
        
        Args:
            cat (str):

        Returns:
            count (int):
        """
        pass

    def StateUIListName(self, cat, index):
        """string name = StateUIListName(string cat,integer index)
        
        Args:
            cat (str):
            index (int):

        Returns:
            name (str):
        """
        pass

    def StateUITestEvent(self, im, stateName, eventID):
        """StateUITestEvent(id im,string stateName,integer eventID)
        
        Args:
            im (id):
            stateName (str):
            eventID (int):

        Returns:
            None
        """
        pass

    def StateUITestRegion(self, im, stateName, regionID):
        """StateUITestRegion(id im,string stateName,integer regionID)
        
        Args:
            im (id):
            stateName (str):
            regionID (int):

        Returns:
            None
        """
        pass

    def StateUserName(self, state):
        """string name = StateUserName(string state)
        
        Args:
            state (str):

        Returns:
            name (str):
        """
        pass

    def TestState(self, im, state):
        """integer priority = TestState(id im,string state)
        
        Args:
            im (id):
            state (str):

        Returns:
            priority (int):
        """
        pass

    def UpdateDeviceInstance(self, name):
        """UpdateDeviceInstance(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass

    def UpdateDeviceList(self):
        """UpdateDeviceList()
        
        Returns:
            None
        """
        pass

    def UserName(self, im):
        """string username = UserName(id im)
        
        Args:
            im (id):

        Returns:
            username (str):
        """
        pass


class Interviewer:
    """Interviewer"""
    def __init__(self):
        pass

    def Arm(self, serverName, target):
        """Arm(string serverName,integer target)
        
        Args:
            serverName (str):
            target (int):

        Returns:
            None
        """
        pass

    def ClearDismissTimer(self, serverName):
        """ClearDismissTimer(string serverName)
        
        Args:
            serverName (str):

        Returns:
            None
        """
        pass

    def Disarm(self, serverName, allowRearm):
        """Disarm(string serverName,integer allowRearm)
        
        Args:
            serverName (str):
            allowRearm (int):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def WasFired(self, serverName):
        """boolean = WasFired(string serverName)
        
        Args:
            serverName (str):

        Returns:
            bool
        """
        pass


class Layer:
    """Layer"""
    def __init__(self):
        pass

    def Bounds(self, index):
        """(vector min,vector max) = Bounds(integer index)
        
        Args:
            index (int):

        Returns:
            (vector min,vector max)
        """
        pass

    def ClearMark(self, item):
        """ClearMark(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            None
        """
        pass

    def Count(self):
        """integer count = Count()
        
        Returns:
            count (int):
        """
        pass

    def CurrentDeformer(self, meshItem):
        """string name = CurrentDeformer(object meshItem)
        
        Args:
            meshItem (meshItem):

        Returns:
            name (str):
        """
        pass

    def CurrentMap(self, type):
        """string name = CurrentMap(integer type)
        
        Args:
            type (int):

        Returns:
            name (str):
        """
        pass

    def CurveSmoothAngle(self, index):
        """float angle = CurveSmoothAngle(integer index)
        
        Args:
            index (int):

        Returns:
            angle (float):
        """
        pass

    def Flags(self, index):
        """integer flags = Flags(integer index)
        
        Args:
            index (int):

        Returns:
            flags (int):
        """
        pass

    def IsProcedural(self, index):
        """IsProcedural(integer index)
        
        Args:
            index (int):

        Returns:
            None
        """
        pass

    def Item(self, index):
        """Item object = Item(integer index)
        
        Args:
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def ItemLookup(self, mode, item):
        """integer index = ItemLookup(integer mode,object item)
        
        Args:
            mode (int):
            item (lxu.object.Item):

        Returns:
            index (int):
        """
        pass

    def LayerChild(self, index, childNumber):
        """integer childIndex = LayerChild(integer index,integer childNumber)
        
        Args:
            index (int):
            childNumber (int):

        Returns:
            childIndex (int):
        """
        pass

    def LayerChildCount(self, index):
        """integer num = LayerChildCount(integer index)
        
        Args:
            index (int):

        Returns:
            num (int):
        """
        pass

    def LayerClip(self, index):
        """Item object = LayerClip(integer index)
        
        Args:
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def LayerClipCount(self):
        """integer num = LayerClipCount()
        
        Returns:
            num (int):
        """
        pass

    def LayerEdge(self, mode, index):
        """Unknown object = LayerEdge(integer mode,integer index)
        
        Args:
            mode (int):
            index (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def LayerEdgeCount(self, mode):
        """integer num = LayerEdgeCount(integer mode)
        
        Args:
            mode (int):

        Returns:
            num (int):
        """
        pass

    def LayerMaterial(self, index):
        """Item object = LayerMaterial(integer index)
        
        Args:
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def LayerMaterialCount(self):
        """integer num = LayerMaterialCount()
        
        Returns:
            num (int):
        """
        pass

    def LayerParent(self, index):
        """integer parentIndex = LayerParent(integer index)
        
        Args:
            index (int):

        Returns:
            parentIndex (int):
        """
        pass

    def LayerPart(self, index):
        """string part = LayerPart(integer index)
        
        Args:
            index (int):

        Returns:
            part (str):
        """
        pass

    def LayerPartCount(self):
        """integer num = LayerPartCount()
        
        Returns:
            num (int):
        """
        pass

    def LayerPoly(self, mode, index):
        """Unknown object = LayerPoly(integer mode,integer index)
        
        Args:
            mode (int):
            index (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def LayerPolyCount(self, mode):
        """integer num = LayerPolyCount(integer mode)
        
        Args:
            mode (int):

        Returns:
            num (int):
        """
        pass

    def LayerSelSet(self, type, index):
        """string selSet = LayerSelSet(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            selSet (str):
        """
        pass

    def LayerSelSetCount(self, type):
        """integer num = LayerSelSetCount(integer type)
        
        Args:
            type (int):

        Returns:
            num (int):
        """
        pass

    def LayerTagTexture(self, layer, type, tag, index):
        """Item object = LayerTagTexture(integer layer,integer type,string tag,integer index)
        
        Args:
            layer (int):
            type (int):
            tag (str):
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def LayerTagTextureCount(self, layer, type, tag):
        """integer num = LayerTagTextureCount(integer layer,integer type,string tag)
        
        Args:
            layer (int):
            type (int):
            tag (str):

        Returns:
            num (int):
        """
        pass

    def LayerTexture(self, layer, index):
        """Item object = LayerTexture(integer layer,integer index)
        
        Args:
            layer (int):
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def LayerTextureCount(self, layer):
        """integer num = LayerTextureCount(integer layer)
        
        Args:
            layer (int):

        Returns:
            num (int):
        """
        pass

    def LayerVMap(self, index):
        """Unknown object = LayerVMap(integer index)
        
        Args:
            index (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def LayerVMapCount(self):
        """integer num = LayerVMapCount()
        
        Returns:
            num (int):
        """
        pass

    def LayerVertex(self, mode, index):
        """Unknown object = LayerVertex(integer mode,integer index)
        
        Args:
            mode (int):
            index (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def LayerVertexCount(self, mode):
        """integer num = LayerVertexCount(integer mode)
        
        Args:
            mode (int):

        Returns:
            num (int):
        """
        pass

    def Mesh(self, index):
        """Mesh object = Mesh(integer index)
        
        Args:
            index (int):

        Returns:
            object (lxu.object.Mesh):
        """
        pass

    def Name(self, index):
        """string name = Name(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def NameLookup(self, mode, name):
        """integer index = NameLookup(integer mode,string name)
        
        Args:
            mode (int):
            name (str):

        Returns:
            index (int):
        """
        pass

    def PatchSubdivision(self, index):
        """integer level = PatchSubdivision(integer index)
        
        Args:
            index (int):

        Returns:
            level (int):
        """
        pass

    def Pivot(self, index):
        """float pivot = Pivot(integer index)
        
        Args:
            index (int):

        Returns:
            pivot (float):
        """
        pass

    def ScanAllocate(self, flags):
        """LayerScan object = ScanAllocate(integer flags)
        
        Args:
            flags (int):

        Returns:
            object (LayerScan):
        """
        pass

    def ScanAllocateItem(self, item, flags):
        """LayerScan object = ScanAllocateItem(object item,integer flags)
        
        Args:
            item (lxu.object.Item):
            flags (int):

        Returns:
            object (LayerScan):
        """
        pass

    def Scene(self):
        """Scene object = Scene()
        
        Returns:
            object (Scene):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SetMark(self, item):
        """SetMark(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            None
        """
        pass

    def SetScene(self, scene):
        """SetScene(object scene)
        
        Args:
            scene (scene):

        Returns:
            None
        """
        pass

    def Slot(self, index):
        """integer slot = Slot(integer index)
        
        Args:
            index (int):

        Returns:
            slot (int):
        """
        pass

    def SplinePatchSubdivision(self, index):
        """integer level = SplinePatchSubdivision(integer index)
        
        Args:
            index (int):

        Returns:
            level (int):
        """
        pass

    def TestMark(self, item):
        """integer = TestMark(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            int
        """
        pass

    def XfrmAllocate(self, toolVec):
        """TransformScan object = XfrmAllocate(object toolVec)
        
        Args:
            toolVec (toolVec):

        Returns:
            object (TransformScan):
        """
        pass


class Listener:
    """Listener"""
    def __init__(self):
        pass

    def AddListener(self, object):
        """AddListener(object object)
        
        Args:
            object (object):

        Returns:
            None
        """
        pass

    def RemoveListener(self, object):
        """RemoveListener(object object)
        
        Args:
            object (object):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Log:
    """Log"""
    def __init__(self):
        pass

    def AcquireMonitor(self):
        """object = AcquireMonitor()
        
        Returns:
            object
        """
        pass

    def CreateEntryInfoBlock(self, type, blockName):
        """LogEntry object = CreateEntryInfoBlock(integer type,string blockName)
        
        Args:
            type (int):
            blockName (str):

        Returns:
            object (LogEntry):
        """
        pass

    def CreateEntryMessage(self, type, message):
        """LogEntry object = CreateEntryMessage(integer type,string message)
        
        Args:
            type (int):
            message (str):

        Returns:
            object (LogEntry):
        """
        pass

    def CreateEntryMessageFromMsgObj(self, msgObj):
        """LogEntry object = CreateEntryMessageFromMsgObj(object msgObj)
        
        Args:
            msgObj (msgObj):

        Returns:
            object (LogEntry):
        """
        pass

    def CreateEntryPaired(self, type):
        """LogEntry object = CreateEntryPaired(integer type)
        
        Args:
            type (int):

        Returns:
            object (LogEntry):
        """
        pass

    def DebugLogOutput(self, level, line):
        """DebugLogOutput(integer level,string line)
        
        Args:
            level (int):
            line (str):

        Returns:
            None
        """
        pass

    def DebugLogOutputSys(self, level, logSystem, line):
        """DebugLogOutputSys(integer level,string logSystem,string line)
        
        Args:
            level (int):
            logSystem (str):
            line (str):

        Returns:
            None
        """
        pass

    def EnableLogging(self, systemName, state):
        """EnableLogging(string systemName,integer state)
        
        Args:
            systemName (str):
            state (int):

        Returns:
            None
        """
        pass

    def ExceptionBlockCollect(self):
        """Message object = ExceptionBlockCollect()
        
        Returns:
            object (Message):
        """
        pass

    def ExceptionBlockStart(self):
        """ExceptionBlockStart()
        
        Returns:
            None
        """
        pass

    def ExceptionMessage(self, error, flags):
        """object = ExceptionMessage(integer error,integer flags)
        
        Args:
            error (int):
            flags (int):

        Returns:
            object
        """
        pass

    def InfoBlockByIndex(self, index):
        """LogInfoBlock object = InfoBlockByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (LogInfoBlock):
        """
        pass

    def InfoBlockCount(self):
        """integer count = InfoBlockCount()
        
        Returns:
            count (int):
        """
        pass

    def InfoBlockFieldGetParts(self, name):
        """(string group,string sub) = InfoBlockFieldGetParts(string name)
        
        Args:
            name (str):

        Returns:
            (string group,string sub)
        """
        pass

    def InfoBlockFieldsAreSameGroup(self, name1, name2):
        """boolean = InfoBlockFieldsAreSameGroup(string name1,string name2)
        
        Args:
            name1 (str):
            name2 (str):

        Returns:
            bool
        """
        pass

    def InfoBlockLookup(self, name):
        """LogInfoBlock object = InfoBlockLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (LogInfoBlock):
        """
        pass

    def IsLoggingEnabled(self, systemName):
        """boolean = IsLoggingEnabled(string systemName)
        
        Args:
            systemName (str):

        Returns:
            bool
        """
        pass

    def MasterSubSystem(self):
        """Log object = MasterSubSystem()
        
        Returns:
            object (Log):
        """
        pass

    def ReplaceEntryMessage(self, logEntry, type, msg):
        """ReplaceEntryMessage(object logEntry,integer type,string msg)
        
        Args:
            logEntry (logEntry):
            type (int):
            msg (str):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SetMonitor(self, monitor):
        """SetMonitor(object monitor)
        
        Args:
            monitor (monitor):

        Returns:
            None
        """
        pass

    def SubSystemByIndex(self, index):
        """Log object = SubSystemByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (Log):
        """
        pass

    def SubSystemCount(self):
        """integer count = SubSystemCount()
        
        Returns:
            count (int):
        """
        pass

    def SubSystemLookup(self, name):
        """Log object = SubSystemLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (Log):
        """
        pass


class Mesh:
    """Mesh"""
    def __init__(self):
        pass

    def ConvertMesh(self, triGroupObj, meshObj):
        """ConvertMesh(object triGroupObj,object meshObj)
        
        Args:
            triGroupObj (triGroupObj):
            meshObj (meshObj):

        Returns:
            None
        """
        pass

    def CreateMesh(self):
        """Mesh object = CreateMesh()
        
        Returns:
            object (lxu.object.Mesh):
        """
        pass

    def CreateSlice(self):
        """PolygonSlice object = CreateSlice()
        
        Returns:
            object (PolygonSlice):
        """
        pass

    def CreateSolidDrill(self):
        """SolidDrill object = CreateSolidDrill()
        
        Returns:
            object (SolidDrill):
        """
        pass

    def CurveGroupFromMesh(self, mesh, xfrm):
        """Unknown object = CurveGroupFromMesh(object mesh,matrix xfrm)
        
        Args:
            mesh (lxu.object.Mesh):
            xfrm (lx.object.Matrix):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def IsMeshProcedural(self, item):
        """boolean = IsMeshProcedural(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def ItemFromMesh(self, mesh):
        """Item object = ItemFromMesh(object mesh)
        
        Args:
            mesh (lxu.object.Mesh):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def MeshFromSurface(self, meshObj, surfItem, surfObj):
        """MeshFromSurface(object meshObj,object surfItem,object surfObj)
        
        Args:
            meshObj (meshObj):
            surfItem (surfItem):
            surfObj (surfObj):

        Returns:
            None
        """
        pass

    def MeshFromTriGroup(self, meshObj, triGroupObj):
        """MeshFromTriGroup(object meshObj,object triGroupObj)
        
        Args:
            meshObj (meshObj):
            triGroupObj (triGroupObj):

        Returns:
            None
        """
        pass

    def ModeCompose(self, set, clear):
        """integer mode = ModeCompose(string set,string clear)
        
        Args:
            set (str):
            clear (str):

        Returns:
            mode (int):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SurfaceFromMesh(self, mesh, meshItem):
        """Surface object = SurfaceFromMesh(object mesh,object meshItem)
        
        Args:
            mesh (lxu.object.Mesh):
            meshItem (meshItem):

        Returns:
            object (Surface):
        """
        pass

    def SurfaceToTriGroup(self, triGroupObj, surfObj):
        """SurfaceToTriGroup(object triGroupObj,object surfObj)
        
        Args:
            triGroupObj (triGroupObj):
            surfObj (surfObj):

        Returns:
            None
        """
        pass

    def Tessellate(self, meshTess, meshSource, xfrm, flags):
        """Tessellate(object meshTess,object meshSource,matrix xfrm,integer flags)
        
        Args:
            meshTess (meshTess):
            meshSource (meshSource):
            xfrm (lx.object.Matrix):
            flags (int):

        Returns:
            None
        """
        pass

    def TriGroupTransform(self, triGroupObj):
        """matrix xfrm = TriGroupTransform(object triGroupObj)
        
        Args:
            triGroupObj (triGroupObj):

        Returns:
            xfrm (lx.object.Matrix):
        """
        pass

    def VMapDimension(self, type):
        """integer dimension = VMapDimension(integer type)
        
        Args:
            type (int):

        Returns:
            dimension (int):
        """
        pass

    def VMapIsContinuous(self, type):
        """boolean = VMapIsContinuous(integer type)
        
        Args:
            type (int):

        Returns:
            bool
        """
        pass

    def VMapIsEdgeMap(self, type):
        """boolean = VMapIsEdgeMap(integer type)
        
        Args:
            type (int):

        Returns:
            bool
        """
        pass

    def VMapLookupName(self, type):
        """string name = VMapLookupName(integer type)
        
        Args:
            type (int):

        Returns:
            name (str):
        """
        pass

    def VMapLookupType(self, name):
        """integer type = VMapLookupType(string name)
        
        Args:
            name (str):

        Returns:
            type (int):
        """
        pass

    def VMapZeroDefault(self, type):
        """boolean = VMapZeroDefault(integer type)
        
        Args:
            type (int):

        Returns:
            bool
        """
        pass

    def ValidateMetaData(self, mesh, name):
        """Unknown object = ValidateMetaData(object mesh,string name)
        
        Args:
            mesh (lxu.object.Mesh):
            name (str):

        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Message:
    """Message"""
    def __init__(self):
        pass

    def Allocate(self):
        """Message object = Allocate()
        
        Returns:
            object (Message):
        """
        pass

    def ArgTypeDesc(self, argType):
        """string = ArgTypeDesc(string argType)
        
        Args:
            argType (str):

        Returns:
            str
        """
        pass

    def ArgTypeOptionDesc(self, argType, option):
        """string = ArgTypeOptionDesc(string argType,string option)
        
        Args:
            argType (str):
            option (str):

        Returns:
            str
        """
        pass

    def ArgTypeOptionUserName(self, argType, option):
        """string = ArgTypeOptionUserName(string argType,string option)
        
        Args:
            argType (str):
            option (str):

        Returns:
            str
        """
        pass

    def ArgTypeUserName(self, argType):
        """string = ArgTypeUserName(string argType)
        
        Args:
            argType (str):

        Returns:
            str
        """
        pass

    def Duplicate(self, msg):
        """Message object = Duplicate(object msg)
        
        Args:
            msg (msg):

        Returns:
            object (Message):
        """
        pass

    def MessageText(self, msg):
        """string = MessageText(object msg)
        
        Args:
            msg (msg):

        Returns:
            str
        """
        pass

    def MessageTextRich(self, msg):
        """string = MessageTextRich(object msg)
        
        Args:
            msg (msg):

        Returns:
            str
        """
        pass

    def RawText(self, table, msg):
        """string text = RawText(string table,string msg)
        
        Args:
            table (str):
            msg (str):

        Returns:
            text (str):
        """
        pass

    def RawTextRich(self, table, msg):
        """string text = RawTextRich(string table,string msg)
        
        Args:
            table (str):
            msg (str):

        Returns:
            text (str):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def StringLookup(self, table, ident):
        """string text = StringLookup(string table,string ident)
        
        Args:
            table (str):
            ident (str):

        Returns:
            text (str):
        """
        pass

    def StripRichText(self, string):
        """string stripped = StripRichText(string string)
        
        Args:
            string (str):

        Returns:
            stripped (str):
        """
        pass


class Network:
    """Network"""
    def __init__(self):
        pass

    def OneOffHostListAdd(self, hostname, ip, port):
        """OneOffHostListAdd(string hostname,integer ip,integer port)
        
        Args:
            hostname (str):
            ip (int):
            port (int):

        Returns:
            None
        """
        pass

    def OneOffHostListRemove(self, hostname, ip, port):
        """OneOffHostListRemove(string hostname,integer ip,integer port)
        
        Args:
            hostname (str):
            ip (int):
            port (int):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Nodal:
    """Nodal"""
    def __init__(self):
        pass

    def AddSampleChan(self, eval, item, chanIndex, type):
        """(integer,integer idxArray) = AddSampleChan(object eval,object item,integer chanIndex,integer type)
        
        Args:
            eval (eval):
            item (lxu.object.Item):
            chanIndex (int):
            type (int):

        Returns:
            idxArray) ((integer,integer):
        """
        pass

    def AddSampleChanName(self, eval, item, chanName, type):
        """(integer,integer idxArray) = AddSampleChanName(object eval,object item,string chanName,integer type)
        
        Args:
            eval (eval):
            item (lxu.object.Item):
            chanName (str):
            type (int):

        Returns:
            idxArray) ((integer,integer):
        """
        pass

    def AnyDrivenChans(self, count):
        """(integer,integer chans) = AnyDrivenChans(integer count)
        
        Args:
            count (int):

        Returns:
            chans) ((integer,integer):
        """
        pass

    def GetFloat(self, etor, index, orig):
        """(float,integer idxArray) = GetFloat(object etor,integer index,float orig)
        
        Args:
            etor (etor):
            index (int):
            orig (float):

        Returns:
            idxArray) ((float,integer):
        """
        pass

    def GetInt(self, etor, index, orig):
        """(integer,integer idxArray) = GetInt(object etor,integer index,integer orig)
        
        Args:
            etor (etor):
            index (int):
            orig (int):

        Returns:
            idxArray) ((integer,integer):
        """
        pass

    def GetValue(self, etor, index, orig):
        """(pointer,integer idxArray) = GetValue(object etor,integer index,pointer orig)
        
        Args:
            etor (etor):
            index (int):
            orig (int):

        Returns:
            idxArray) ((pointer,integer):
        """
        pass

    def IsDriven(self, item, chanIndex):
        """integer = IsDriven(object item,integer chanIndex)
        
        Args:
            item (lxu.object.Item):
            chanIndex (int):

        Returns:
            int
        """
        pass

    def IsDrivenName(self, item, chanName):
        """integer = IsDrivenName(object item,string chanName)
        
        Args:
            item (lxu.object.Item):
            chanName (str):

        Returns:
            int
        """
        pass


class NotifySys:
    """NotifySys"""
    def __init__(self):
        pass

    def ByIndex(self, index):
        """Notifier object = ByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (lx.object.Notifier):
        """
        pass

    def Count(self):
        """integer count = Count()
        
        Returns:
            count (int):
        """
        pass

    def Lookup(self, name, args):
        """Notifier object = Lookup(string name,string args)
        
        Args:
            name (str):
            args (str):

        Returns:
            object (lx.object.Notifier):
        """
        pass

    def NameByIndex(self, index):
        """string name = NameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Spawn(self, name, args):
        """Notifier object = Spawn(string name,string args)
        
        Args:
            name (str):
            args (str):

        Returns:
            object (lx.object.Notifier):
        """
        pass


class Packet:
    """Packet"""
    def __init__(self):
        pass

    def AddPacket(self, vtype, name, flags):
        """AddPacket(object vtype,string name,integer flags)
        
        Args:
            vtype (vtype):
            name (str):
            flags (int):

        Returns:
            None
        """
        pass

    def CreateVectorType(self, category):
        """VectorType object = CreateVectorType(string category)
        
        Args:
            category (str):

        Returns:
            object (VectorType):
        """
        pass

    def FastPacket(self, vector, offset):
        """pointer = FastPacket(object vector,integer offset)
        
        Args:
            vector (tuple):
            offset (int):

        Returns:
            int
        """
        pass

    def Lookup(self, category, name):
        """integer offset = Lookup(string category,string name)
        
        Args:
            category (str):
            name (str):

        Returns:
            offset (int):
        """
        pass

    def Name(self, category, offset):
        """string name = Name(string category,integer offset)
        
        Args:
            category (str):
            offset (int):

        Returns:
            name (str):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Particle:
    """Particle"""
    def __init__(self):
        pass

    def EnumParticleFeatures(self, item, visitor):
        """EnumParticleFeatures(object item,object visitor)
        
        Args:
            item (lxu.object.Item):
            visitor (visitor):

        Returns:
            None
        """
        pass

    def EnumeratorEvaluate(self, attr, index):
        """ReplicatorEnumerator object = EnumeratorEvaluate(object attr,integer index)
        
        Args:
            attr (attr):
            index (int):

        Returns:
            object (ReplicatorEnumerator):
        """
        pass

    def EnumeratorPrepare(self, eval, replItem):
        """integer index = EnumeratorPrepare(object eval,object replItem)
        
        Args:
            eval (eval):
            replItem (replItem):

        Returns:
            index (int):
        """
        pass

    def FeatureIdent(self):
        """string ident = FeatureIdent()
        
        Returns:
            ident (str):
        """
        pass

    def FeatureOffset(self):
        """integer offset = FeatureOffset()
        
        Returns:
            offset (int):
        """
        pass

    def GetReplicatorEnumerator(self, replicatorItem):
        """ReplicatorEnumerator object = GetReplicatorEnumerator(object replicatorItem)
        
        Args:
            replicatorItem (replicatorItem):

        Returns:
            object (ReplicatorEnumerator):
        """
        pass

    def ItemToParticle(self, item, chanRead):
        """Unknown object = ItemToParticle(object item,object chanRead)
        
        Args:
            item (lxu.object.Item):
            chanRead (chanRead):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def TriGroupBlend(self, triGroup0, triGroup1, blend):
        """TriGroupBlend(object triGroup0,object triGroup1,float blend)
        
        Args:
            triGroup0 (triGroup0):
            triGroup1 (triGroup1):
            blend (float):

        Returns:
            None
        """
        pass

    def TriGroupToParticle(self, triGroup):
        """Unknown object = TriGroupToParticle(object triGroup)
        
        Args:
            triGroup (triGroup):

        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Persistence:
    """Persistence"""
    def __init__(self):
        pass

    def AddValue(self, typeName):
        """AddValue(string typeName)
        
        Args:
            typeName (str):

        Returns:
            None
        """
        pass

    def Configure(self, name, obj):
        """Configure(string name,object obj)
        
        Args:
            name (str):
            obj (obj):

        Returns:
            None
        """
        pass

    def End(self):
        """PersistentEntry object = End()
        
        Returns:
            object (PersistentEntry):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Start(self, name, type):
        """Start(string name,integer type)
        
        Args:
            name (str):
            type (int):

        Returns:
            None
        """
        pass


class Platform:
    """Platform"""
    def __init__(self):
        pass

    def AppBuild(self):
        """integer build = AppBuild()
        
        Returns:
            build (int):
        """
        pass

    def AppName(self):
        """string name = AppName()
        
        Returns:
            name (str):
        """
        pass

    def AppUsername(self):
        """string name = AppUsername()
        
        Returns:
            name (str):
        """
        pass

    def AppVersion(self):
        """integer version = AppVersion()
        
        Returns:
            version (int):
        """
        pass

    def AppVersionMajor(self):
        """integer version = AppVersionMajor()
        
        Returns:
            version (int):
        """
        pass

    def AppVersionMinor(self):
        """integer version = AppVersionMinor()
        
        Returns:
            version (int):
        """
        pass

    def AppVersionSP(self):
        """integer version = AppVersionSP()
        
        Returns:
            version (int):
        """
        pass

    def CancelDoWhenUserIsIdle(self, visitor, flags):
        """CancelDoWhenUserIsIdle(object visitor,integer flags)
        
        Args:
            visitor (visitor):
            flags (int):

        Returns:
            None
        """
        pass

    def DoWhenUserIsIdle(self, visitor, flags):
        """DoWhenUserIsIdle(object visitor,integer flags)
        
        Args:
            visitor (visitor):
            flags (int):

        Returns:
            None
        """
        pass

    def ExpiresIn(self):
        """integer daysLeft = ExpiresIn()
        
        Returns:
            daysLeft (int):
        """
        pass

    def ImportPathByIndex(self, index):
        """string path = ImportPathByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            path (str):
        """
        pass

    def ImportPathCount(self):
        """integer index = ImportPathCount()
        
        Returns:
            index (int):
        """
        pass

    def IsApp64Bit(self):
        """boolean = IsApp64Bit()
        
        Returns:
            bool
        """
        pass

    def IsAppActive(self):
        """boolean = IsAppActive()
        
        Returns:
            bool
        """
        pass

    def IsHeadless(self):
        """boolean = IsHeadless()
        
        Returns:
            bool
        """
        pass

    def IsSafeMode(self):
        """boolean = IsSafeMode()
        
        Returns:
            bool
        """
        pass

    def IsUserIdle(self):
        """boolean = IsUserIdle()
        
        Returns:
            bool
        """
        pass

    def LicensedTo(self):
        """string licensee = LicensedTo()
        
        Returns:
            licensee (str):
        """
        pass

    def NumLicenses(self):
        """integer licenses = NumLicenses()
        
        Returns:
            licenses (int):
        """
        pass

    def OSName(self):
        """string name = OSName()
        
        Returns:
            name (str):
        """
        pass

    def OSType(self):
        """integer type = OSType()
        
        Returns:
            type (int):
        """
        pass

    def OSVersion(self):
        """string version = OSVersion()
        
        Returns:
            version (str):
        """
        pass

    def PathByIndex(self, index):
        """string path = PathByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            path (str):
        """
        pass

    def PathCount(self):
        """integer count = PathCount()
        
        Returns:
            count (int):
        """
        pass

    def PathNameByIndex(self, index):
        """string name = PathNameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SerialNumber(self):
        """string serial = SerialNumber()
        
        Returns:
            serial (str):
        """
        pass

    def SessionStage(self):
        """integer stage = SessionStage()
        
        Returns:
            stage (int):
        """
        pass

    def TimerCancel(self, visitor, idleFlags):
        """TimerCancel(object visitor,integer idleFlags)
        
        Args:
            visitor (visitor):
            idleFlags (int):

        Returns:
            None
        """
        pass

    def TimerStart(self, visitor, milliseconds, idleFlags):
        """TimerStart(object visitor,integer milliseconds,integer idleFlags)
        
        Args:
            visitor (visitor):
            milliseconds (int):
            idleFlags (int):

        Returns:
            None
        """
        pass


class PresetBrowser:
    """PresetBrowser"""
    def __init__(self):
        pass

    def GetSpecialSelModePath(self, identifier):
        """string = GetSpecialSelModePath(string identifier)
        
        Args:
            identifier (str):

        Returns:
            str
        """
        pass

    def IsViewportVisible(self, identifier, hash):
        """boolean = IsViewportVisible(string identifier,string hash)
        
        Args:
            identifier (str):
            hash (str):

        Returns:
            bool
        """
        pass

    def RecognizeFile(self, path, flags):
        """(string serverName,string category) = RecognizeFile(string path,integer flags)
        
        Args:
            path (str):
            flags (int):

        Returns:
            (string serverName,string category)
        """
        pass

    def RecognizeFileForce(self, path, flags):
        """(string serverName,string category) = RecognizeFileForce(string path,integer flags)
        
        Args:
            path (str):
            flags (int):

        Returns:
            (string serverName,string category)
        """
        pass

    def Rescan(self, path):
        """Rescan(string path)
        
        Args:
            path (str):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ServerByIndex(self, index):
        """PresetType object = ServerByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (PresetType):
        """
        pass

    def ServerCount(self):
        """integer count = ServerCount()
        
        Returns:
            count (int):
        """
        pass

    def ServerLookup(self, name):
        """PresetType object = ServerLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (PresetType):
        """
        pass

    def ServerNameByIndex(self, index):
        """string name = ServerNameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def ServerUserNameByIndex(self, index):
        """string name = ServerUserNameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def SetSpecialSelModePath(self, identifier, path, asInteractive):
        """SetSpecialSelModePath(string identifier,string path,integer asInteractive)
        
        Args:
            identifier (str):
            path (str):
            asInteractive (int):

        Returns:
            None
        """
        pass

    def SubtypeFromIdentifier(self, identifier):
        """integer subtype = SubtypeFromIdentifier(string identifier)
        
        Args:
            identifier (str):

        Returns:
            subtype (int):
        """
        pass

    def UpdateIdentifierState(self, identifier, path):
        """UpdateIdentifierState(string identifier,string path)
        
        Args:
            identifier (str):
            path (str):

        Returns:
            None
        """
        pass


class PresetDestination:
    """PresetDestination"""
    def __init__(self):
        pass

    def ApplyMeshPresetToMeshPD(self, predest, filepath):
        """ApplyMeshPresetToMeshPD(object predest,string filepath)
        
        Args:
            predest (predest):
            filepath (str):

        Returns:
            None
        """
        pass

    def ApplyProfilePDToMesh(self, predest, tolerance, freeze, axis, mesh):
        """ApplyProfilePDToMesh(object predest,float tolerance,integer freeze,integer axis,object mesh)
        
        Args:
            predest (predest):
            tolerance (float):
            freeze (int):
            axis (int):
            mesh (lxu.object.Mesh):

        Returns:
            None
        """
        pass

    def CreateMeshLayerPD(self, mesh, shadeItem):
        """Unknown object = CreateMeshLayerPD(object mesh,object shadeItem)
        
        Args:
            mesh (lxu.object.Mesh):
            shadeItem (shadeItem):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Profile1DPDFromPath(self, filepath):
        """Unknown object = Profile1DPDFromPath(string filepath)
        
        Args:
            filepath (str):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Profile2DPDFromPath(self, filepath):
        """Unknown object = Profile2DPDFromPath(string filepath)
        
        Args:
            filepath (str):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ShaderPDFromItem(self, item):
        """Unknown object = ShaderPDFromItem(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Preview:
    """Preview"""
    def __init__(self):
        pass

    def CreatePreview(self):
        """Preview object = CreatePreview()
        
        Returns:
            object (Preview):
        """
        pass

    def GetMeshPreview(self, item, width, height):
        """Unknown object = GetMeshPreview(object item,integer width,integer height)
        
        Args:
            item (lxu.object.Item):
            width (int):
            height (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Render:
    """Render"""
    def __init__(self):
        pass

    def FrameDelete(self, slotIndex):
        """FrameDelete(integer slotIndex)
        
        Args:
            slotIndex (int):

        Returns:
            None
        """
        pass

    def FrameRecall(self, slotIndex, passIndex, monitor):
        """FrameBuffer object = FrameRecall(integer slotIndex,integer passIndex,object monitor)
        
        Args:
            slotIndex (int):
            passIndex (int):
            monitor (monitor):

        Returns:
            object (FrameBuffer):
        """
        pass

    def FrameRecallStats(self, slotIndex):
        """RenderStats object = FrameRecallStats(integer slotIndex)
        
        Args:
            slotIndex (int):

        Returns:
            object (RenderStats):
        """
        pass

    def FrameRecallThumbnail(self, slotIndex):
        """Image object = FrameRecallThumbnail(integer slotIndex)
        
        Args:
            slotIndex (int):

        Returns:
            object (lx.object.Image):
        """
        pass

    def FrameRenderPassCount(self, slotIndex):
        """integer numPasses = FrameRenderPassCount(integer slotIndex)
        
        Args:
            slotIndex (int):

        Returns:
            numPasses (int):
        """
        pass

    def FrameRenderPassInfo(self, slotIndex, passIndex, name):
        """(integer width,integer height,integer outputCount,integer isStereo,integer eyeDisplay,integer stereoComposite) = FrameRenderPassInfo(integer slotIndex,integer passIndex,byte[] name)
        
        Args:
            slotIndex (int):
            passIndex (int):
            name (byte[]):

        Returns:
            (integer width,integer height,integer outputCount,integer isStereo,integer eyeDisplay,integer stereoComposite)
        """
        pass

    def FrameSaveImage(self, framebuffer, bufferIndex, filename, format, message, monitor):
        """FrameSaveImage(object framebuffer,integer bufferIndex,string filename,string format,object message,object monitor)
        
        Args:
            framebuffer (framebuffer):
            bufferIndex (int):
            filename (str):
            format (str):
            message (message):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def FrameSaveLayered(self, framebuffer, filename, format, message, monitor):
        """FrameSaveLayered(object framebuffer,string filename,string format,object message,object monitor)
        
        Args:
            framebuffer (framebuffer):
            filename (str):
            format (str):
            message (message):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def FrameSavePassLayered(self, framebuffer, filename, format, message, monitor):
        """FrameSavePassLayered(object framebuffer,string filename,string format,object message,object monitor)
        
        Args:
            framebuffer (framebuffer):
            filename (str):
            format (str):
            message (message):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def FrameSavePassesAsImages(self, slotIndex, filename, format, message, monitor):
        """FrameSavePassesAsImages(integer slotIndex,string filename,string format,object message,object monitor)
        
        Args:
            slotIndex (int):
            filename (str):
            format (str):
            message (message):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def FrameSavePassesAsLayeredImages(self, slotIndex, filename, format, message, monitor):
        """FrameSavePassesAsLayeredImages(integer slotIndex,string filename,string format,object message,object monitor)
        
        Args:
            slotIndex (int):
            filename (str):
            format (str):
            message (message):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def FrameStore(self, frameBuffer, writePixels):
        """FrameStore(object frameBuffer,integer writePixels)
        
        Args:
            frameBuffer (frameBuffer):
            writePixels (int):

        Returns:
            None
        """
        pass

    def FrameStoreStats(self, slotIndex, stats):
        """FrameStoreStats(integer slotIndex,object stats)
        
        Args:
            slotIndex (int):
            stats (stats):

        Returns:
            None
        """
        pass

    def FrameStoreThumbnail(self, slotIndex, image):
        """FrameStoreThumbnail(integer slotIndex,object image)
        
        Args:
            slotIndex (int):
            image (lx.object.Image):

        Returns:
            None
        """
        pass

    def FrameTestRecall(self, slotIndex, passIndex):
        """boolean = FrameTestRecall(integer slotIndex,integer passIndex)
        
        Args:
            slotIndex (int):
            passIndex (int):

        Returns:
            bool
        """
        pass

    def JobAbort(self):
        """JobAbort()
        
        Returns:
            None
        """
        pass

    def JobCleanup(self, clearJob):
        """JobCleanup(integer clearJob)
        
        Args:
            clearJob (int):

        Returns:
            None
        """
        pass

    def JobCurrent(self):
        """RenderJob object = JobCurrent()
        
        Returns:
            object (RenderJob):
        """
        pass

    def JobIsSlave(self):
        """integer = JobIsSlave()
        
        Returns:
            int
        """
        pass

    def JobRenderOutputCount(self):
        """integer count = JobRenderOutputCount()
        
        Returns:
            count (int):
        """
        pass

    def JobRenderOutputName(self, index):
        """string name = JobRenderOutputName(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def JobRenderOutputType(self, index):
        """integer type = JobRenderOutputType(integer index)
        
        Args:
            index (int):

        Returns:
            type (int):
        """
        pass

    def JobSetCurrent(self, job):
        """JobSetCurrent(object job)
        
        Args:
            job (job):

        Returns:
            None
        """
        pass

    def JobStart(self):
        """JobStart()
        
        Returns:
            None
        """
        pass

    def JobStats(self):
        """object = JobStats()
        
        Returns:
            object
        """
        pass

    def JobStatus(self):
        """JobStatus()
        
        Returns:
            None
        """
        pass

    def RefreshProgressImageMetrics(self):
        """RefreshProgressImageMetrics()
        
        Returns:
            None
        """
        pass

    def RenderEffectFromRenderType(self, type):
        """string effectName = RenderEffectFromRenderType(integer type)
        
        Args:
            type (int):

        Returns:
            effectName (str):
        """
        pass

    def RenderEffectToType(self, effect):
        """(integer type,integer size) = RenderEffectToType(string effect)
        
        Args:
            effect (str):

        Returns:
            (integer type,integer size)
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def UpdateProgressImage(self):
        """UpdateProgressImage()
        
        Returns:
            None
        """
        pass


class RenderCache:
    """RenderCache"""
    def __init__(self):
        pass

    def CreateRenderCache(self, createFlags):
        """RenderCache object = CreateRenderCache(integer createFlags)
        
        Args:
            createFlags (int):

        Returns:
            object (RenderCache):
        """
        pass


class Scene:
    """Scene"""
    def __init__(self):
        pass

    def AllocEmptyCollection(self):
        """ItemCollection object = AllocEmptyCollection()
        
        Returns:
            object (ItemCollection):
        """
        pass

    def ChannelVectorSize(self, mode):
        """integer size = ChannelVectorSize(integer mode)
        
        Args:
            mode (int):

        Returns:
            size (int):
        """
        pass

    def ChannelVectorTextHints(self):
        """hints hints = ChannelVectorTextHints()
        
        Returns:
            hints (hints):
        """
        pass

    def CloseCollection(self, collection, mode):
        """CloseCollection(object collection,integer mode)
        
        Args:
            collection (collection):
            mode (int):

        Returns:
            None
        """
        pass

    def CreateScene(self):
        """Scene object = CreateScene()
        
        Returns:
            object (Scene):
        """
        pass

    def DestroyScene(self, scene):
        """DestroyScene(object scene)
        
        Args:
            scene (scene):

        Returns:
            None
        """
        pass

    def GetMeshInstSourceItem(self, inst):
        """Item object = GetMeshInstSourceItem(object inst)
        
        Args:
            inst (inst):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def GetReplicatorEnumerator(self, replicatorItem):
        """ReplicatorEnumerator object = GetReplicatorEnumerator(object replicatorItem)
        
        Args:
            replicatorItem (replicatorItem):

        Returns:
            object (ReplicatorEnumerator):
        """
        pass

    def ItemGraphCollection(self, collection, type, graph, fwd):
        """ItemGraphCollection(object collection,integer type,string graph,integer fwd)
        
        Args:
            collection (collection):
            type (int):
            graph (str):
            fwd (int):

        Returns:
            None
        """
        pass

    def ItemSubTypeByIndex(self, type, index):
        """string subtype = ItemSubTypeByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            subtype (str):
        """
        pass

    def ItemSubTypeCount(self, type):
        """integer count = ItemSubTypeCount(integer type)
        
        Args:
            type (int):

        Returns:
            count (int):
        """
        pass

    def ItemTypeByIndex(self, index):
        """integer type = ItemTypeByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            type (int):
        """
        pass

    def ItemTypeCommonChannels(self, item1, item2):
        """integer count = ItemTypeCommonChannels(object item1,object item2)
        
        Args:
            item1 (item1):
            item2 (item2):

        Returns:
            count (int):
        """
        pass

    def ItemTypeCount(self):
        """integer = ItemTypeCount()
        
        Returns:
            int
        """
        pass

    def ItemTypeGetTag(self, type, tag, super):
        """string value = ItemTypeGetTag(integer type,string tag,integer super)
        
        Args:
            type (int):
            tag (str):
            super (int):

        Returns:
            value (str):
        """
        pass

    def ItemTypeLookup(self, name):
        """integer type = ItemTypeLookup(string name)
        
        Args:
            name (str):

        Returns:
            type (int):
        """
        pass

    def ItemTypeName(self, type):
        """string name = ItemTypeName(integer type)
        
        Args:
            type (int):

        Returns:
            name (str):
        """
        pass

    def ItemTypeSuper(self, type):
        """integer super = ItemTypeSuper(integer type)
        
        Args:
            type (int):

        Returns:
            super (int):
        """
        pass

    def ItemTypeSupportsInterface(self, type, guid):
        """boolean = ItemTypeSupportsInterface(integer type,string guid)
        
        Args:
            type (int):
            guid (str):

        Returns:
            bool
        """
        pass

    def ItemTypeTest(self, what, isA):
        """boolean = ItemTypeTest(integer what,integer isA)
        
        Args:
            what (int):
            isA (int):

        Returns:
            bool
        """
        pass

    def LoadImage(self, scene, path, monitor):
        """Item object = LoadImage(object scene,string path,object monitor)
        
        Args:
            scene (scene):
            path (str):
            monitor (monitor):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def MeshInstanceByIndex(self, mesh, index):
        """Item object = MeshInstanceByIndex(object mesh,integer index)
        
        Args:
            mesh (lxu.object.Mesh):
            index (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def MeshInstanceCount(self, mesh):
        """integer = MeshInstanceCount(object mesh)
        
        Args:
            mesh (lxu.object.Mesh):

        Returns:
            int
        """
        pass

    def Root(self):
        """Scene object = Root()
        
        Returns:
            object (Scene):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SubSceneAdd(self, scene, other, refItems):
        """SubSceneAdd(object scene,object other,integer refItems)
        
        Args:
            scene (scene):
            other (other):
            refItems (int):

        Returns:
            None
        """
        pass

    def SubSceneLoad(self, scene, path, monitor):
        """Scene object = SubSceneLoad(object scene,string path,object monitor)
        
        Args:
            scene (scene):
            path (str):
            monitor (monitor):

        Returns:
            object (Scene):
        """
        pass


class ScriptSys:
    """ScriptSys"""
    def __init__(self):
        pass

    def ByIndex(self, index):
        """ScriptManager object = ByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (ScriptManager):
        """
        pass

    def Count(self):
        """integer count = Count()
        
        Returns:
            count (int):
        """
        pass

    def Desc(self, manager):
        """string name = Desc(object manager)
        
        Args:
            manager (manager):

        Returns:
            name (str):
        """
        pass

    def KitByIndex(self, index, visible):
        """Kit object = KitByIndex(integer index,integer visible)
        
        Args:
            index (int):
            visible (int):

        Returns:
            object (Kit):
        """
        pass

    def KitCount(self, visible):
        """integer count = KitCount(integer visible)
        
        Args:
            visible (int):

        Returns:
            count (int):
        """
        pass

    def KitLookup(self, name):
        """Kit object = KitLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (Kit):
        """
        pass

    def Lookup(self, name):
        """ScriptManager object = Lookup(string name)
        
        Args:
            name (str):

        Returns:
            object (ScriptManager):
        """
        pass

    def NameByIndex(self, index):
        """string name = NameByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def ResolveAlias(self, alias):
        """string path = ResolveAlias(string alias)
        
        Args:
            alias (str):

        Returns:
            path (str):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def UserName(self, manager):
        """string name = UserName(object manager)
        
        Args:
            manager (manager):

        Returns:
            name (str):
        """
        pass

    def UserValueByIndex(self, index):
        """UserValue object = UserValueByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (UserValue):
        """
        pass

    def UserValueCount(self):
        """integer count = UserValueCount()
        
        Returns:
            count (int):
        """
        pass

    def UserValueLookup(self, name):
        """UserValue object = UserValueLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (UserValue):
        """
        pass


class Selection:
    """Selection"""
    def __init__(self):
        pass

    def AbortBatch(self):
        """AbortBatch()
        
        Returns:
            None
        """
        pass

    def Allocate(self, name):
        """SelectionType object = Allocate(string name)
        
        Args:
            name (str):

        Returns:
            object (SelectionType):
        """
        pass

    def ByIndex(self, type, idx):
        """pointer = ByIndex(integer type,integer idx)
        
        Args:
            type (int):
            idx (int):

        Returns:
            int
        """
        pass

    def Clear(self, type):
        """Clear(integer type)
        
        Args:
            type (int):

        Returns:
            None
        """
        pass

    def Count(self, type):
        """integer = Count(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def CurrentSubTypes(self, type, sub, len):
        """integer num = CurrentSubTypes(integer type,unsigned[] sub,integer len)
        
        Args:
            type (int):
            sub (unsigned[]):
            len (int):

        Returns:
            num (int):
        """
        pass

    def CurrentType(self, types):
        """integer = CurrentType(unsigned[] types)
        
        Args:
            types (unsigned[]):

        Returns:
            int
        """
        pass

    def Deselect(self, type, packet):
        """Deselect(integer type,pointer packet)
        
        Args:
            type (int):
            packet (int):

        Returns:
            None
        """
        pass

    def Drop(self, type):
        """Drop(integer type)
        
        Args:
            type (int):

        Returns:
            None
        """
        pass

    def EndBatch(self):
        """EndBatch()
        
        Returns:
            None
        """
        pass

    def GetTime(self):
        """float = GetTime()
        
        Returns:
            float
        """
        pass

    def LookupName(self, type):
        """string = LookupName(integer type)
        
        Args:
            type (int):

        Returns:
            str
        """
        pass

    def LookupType(self, name):
        """integer = LookupType(string name)
        
        Args:
            name (str):

        Returns:
            int
        """
        pass

    def Recent(self, type):
        """pointer = Recent(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def Remove(self, type, packet):
        """Remove(integer type,pointer packet)
        
        Args:
            type (int):
            packet (int):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Select(self, type, packet):
        """Select(integer type,pointer packet)
        
        Args:
            type (int):
            packet (int):

        Returns:
            None
        """
        pass

    def SetTime(self, time):
        """SetTime(float time)
        
        Args:
            time (float):

        Returns:
            None
        """
        pass

    def StartBatch(self):
        """StartBatch()
        
        Returns:
            None
        """
        pass

    def State(self, type, packet):
        """integer = State(integer type,pointer packet)
        
        Args:
            type (int):
            packet (int):

        Returns:
            int
        """
        pass

    def Test(self, type, packet):
        """boolean = Test(integer type,pointer packet)
        
        Args:
            type (int):
            packet (int):

        Returns:
            bool
        """
        pass

    def Toggle(self, type, packet):
        """Toggle(integer type,pointer packet)
        
        Args:
            type (int):
            packet (int):

        Returns:
            None
        """
        pass


class Shader:
    """Shader"""
    def __init__(self):
        pass

    def CollectMaterials(self, collection):
        """CollectMaterials(object collection)
        
        Args:
            collection (collection):

        Returns:
            None
        """
        pass

    def ColorBlendValue(self, c1, c2, opa, mode):
        """vector c = ColorBlendValue(vector c1,vector c2,float opa,integer mode)
        
        Args:
            c1 (tuple):
            c2 (tuple):
            opa (float):
            mode (int):

        Returns:
            c (tuple):
        """
        pass

    def ComputeFresnel(self, inRay, normalRay, normReflAmt):
        """float = ComputeFresnel(vector inRay,vector normalRay,float normReflAmt)
        
        Args:
            inRay (tuple):
            normalRay (tuple):
            normReflAmt (float):

        Returns:
            float
        """
        pass

    def MeshShaderAccessor(self, meshItem):
        """Shader object = MeshShaderAccessor(object meshItem)
        
        Args:
            meshItem (meshItem):

        Returns:
            object (Shader):
        """
        pass

    def NextRandom(self, vector):
        """float = NextRandom(object vector)
        
        Args:
            vector (tuple):

        Returns:
            float
        """
        pass

    def PoissonOffset(self, vector):
        """(float u,float v) = PoissonOffset(object vector)
        
        Args:
            vector (tuple):

        Returns:
            (float u,float v)
        """
        pass

    def PolyShaderAccessor(self, meshItem, polyID):
        """Shader object = PolyShaderAccessor(object meshItem,id polyID)
        
        Args:
            meshItem (meshItem):
            polyID (id):

        Returns:
            object (Shader):
        """
        pass

    def RussianRoulette(self, vector, importance):
        """float = RussianRoulette(object vector,float importance)
        
        Args:
            vector (tuple):
            importance (float):

        Returns:
            float
        """
        pass

    def SampleCloud(self, sample):
        """SampleCloud object = SampleCloud(object sample)
        
        Args:
            sample (sample):

        Returns:
            object (SampleCloud):
        """
        pass

    def ScalarBlendValue(self, v1, v2, opa, mode):
        """float = ScalarBlendValue(float v1,float v2,float opa,integer mode)
        
        Args:
            v1 (float):
            v2 (float):
            opa (float):
            mode (int):

        Returns:
            float
        """
        pass

    def SquareToCircle(self, x, y):
        """SquareToCircle(float[] x,float[] y)
        
        Args:
            x (float[]):
            y (float[]):

        Returns:
            None
        """
        pass


class StdDialog:
    """StdDialog"""
    def __init__(self):
        pass

    def AsyncMonitorAllocate(self, system, title):
        """AsyncMonitor object = AsyncMonitorAllocate(string system,string title)
        
        Args:
            system (str):
            title (str):

        Returns:
            object (AsyncMonitor):
        """
        pass

    def AsyncMonitorAllocateWithoutAbort(self, system, title):
        """Unknown object = AsyncMonitorAllocateWithoutAbort(string system,string title)
        
        Args:
            system (str):
            title (str):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def AsyncMonitorLookup(self, ident):
        """Monitor object = AsyncMonitorLookup(string ident)
        
        Args:
            ident (str):

        Returns:
            object (Monitor):
        """
        pass

    def AsyncMonitorRelease(self, monitor):
        """AsyncMonitorRelease(object monitor)
        
        Args:
            monitor (monitor):

        Returns:
            None
        """
        pass

    def AsyncMonitorSubAllocate(self, parent, title):
        """AsyncMonitor object = AsyncMonitorSubAllocate(object parent,string title)
        
        Args:
            parent (parent):
            title (str):

        Returns:
            object (AsyncMonitor):
        """
        pass

    def AsyncMonitorSystemByIndex(self, index):
        """AsyncMonitorSystem object = AsyncMonitorSystemByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (AsyncMonitorSystem):
        """
        pass

    def AsyncMonitorSystemCount(self):
        """integer count = AsyncMonitorSystemCount()
        
        Returns:
            count (int):
        """
        pass

    def AsyncMonitorSystemLookup(self, name):
        """AsyncMonitorSystem object = AsyncMonitorSystemLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (AsyncMonitorSystem):
        """
        pass

    def FileDialog(self, dlgObj):
        """FileDialog(object dlgObj)
        
        Args:
            dlgObj (dlgObj):

        Returns:
            None
        """
        pass

    def MessageAllocate(self):
        """Message object = MessageAllocate()
        
        Returns:
            object (Message):
        """
        pass

    def MessageOpen(self, message, title, helpURL, cookie):
        """MessageOpen(object message,string title,string helpURL,string cookie)
        
        Args:
            message (message):
            title (str):
            helpURL (str):
            cookie (str):

        Returns:
            None
        """
        pass

    def MonitorAllocate(self, title):
        """Monitor object = MonitorAllocate(string title)
        
        Args:
            title (str):

        Returns:
            object (Monitor):
        """
        pass

    def MonitorRelease(self):
        """MonitorRelease()
        
        Returns:
            None
        """
        pass

    def MonitorReleaseObj(self, monitor):
        """MonitorReleaseObj(object monitor)
        
        Args:
            monitor (monitor):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class Tableau:
    """Tableau"""
    def __init__(self):
        pass

    def AllocVertex(self):
        """TableauVertex object = AllocVertex()
        
        Returns:
            object (TableauVertex):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def VertexFromFeatures(self, surfObj, vertex):
        """VertexFromFeatures(object surfObj,object vertex)
        
        Args:
            surfObj (surfObj):
            vertex (vertex):

        Returns:
            None
        """
        pass


class TextEncoding:
    """TextEncoding"""
    def __init__(self):
        pass

    def Allocate(self):
        """TextEncoding object = Allocate()
        
        Returns:
            object (TextEncoding):
        """
        pass


class Thread:
    """Thread"""
    def __init__(self):
        pass

    def CleanupThread(self):
        """CleanupThread()
        
        Returns:
            None
        """
        pass

    def CreateCS(self):
        """ThreadMutex object = CreateCS()
        
        Returns:
            object (ThreadMutex):
        """
        pass

    def CreateGroup(self):
        """ThreadGroup object = CreateGroup()
        
        Returns:
            object (ThreadGroup):
        """
        pass

    def CreateMutex(self):
        """ThreadMutex object = CreateMutex()
        
        Returns:
            object (ThreadMutex):
        """
        pass

    def CreateSlot(self, size, client):
        """ThreadSlot object = CreateSlot(integer size,object client)
        
        Args:
            size (int):
            client (client):

        Returns:
            object (ThreadSlot):
        """
        pass

    def InitThread(self):
        """InitThread()
        
        Returns:
            None
        """
        pass

    def IsMainThread(self):
        """integer = IsMainThread()
        
        Returns:
            int
        """
        pass

    def NumProcs(self):
        """integer = NumProcs()
        
        Returns:
            int
        """
        pass

    def ProcessRange(self, data, startIndex, endIndex, rangeWorker):
        """ProcessRange(pointer data,integer startIndex,integer endIndex,object rangeWorker)
        
        Args:
            data (int):
            startIndex (int):
            endIndex (int):
            rangeWorker (rangeWorker):

        Returns:
            None
        """
        pass

    def ProcessShared(self, shared):
        """ProcessShared(object shared)
        
        Args:
            shared (shared):

        Returns:
            None
        """
        pass

    def ProcessWaterfall(self, waterfall, threads):
        """ProcessWaterfall(object waterfall,integer threads)
        
        Args:
            waterfall (waterfall):
            threads (int):

        Returns:
            None
        """
        pass


class Undo:
    """Undo"""
    def __init__(self):
        pass

    def Apply(self, undo):
        """Apply(object undo)
        
        Args:
            undo (undo):

        Returns:
            None
        """
        pass

    def Record(self, undo):
        """Record(object undo)
        
        Args:
            undo (undo):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def State(self):
        """integer = State()
        
        Returns:
            int
        """
        pass


class Value:
    """Value"""
    def __init__(self):
        pass

    def ConvertValues(self, from_str, to_str):
        """ValueConversion object = ConvertValues(string from_str,string to_str)
        
        Args:
            from_str (str):
            to_str (str):

        Returns:
            object (ValueConversion):
        """
        pass

    def CreateValue(self, type):
        """Value object = CreateValue(string type)
        
        Args:
            type (str):

        Returns:
            object (Value):
        """
        pass

    def FloatType(self, val):
        """integer = FloatType(float val)
        
        Args:
            val (float):

        Returns:
            int
        """
        pass

    def FrameToTime(self, frame):
        """float = FrameToTime(float frame)
        
        Args:
            frame (float):

        Returns:
            float
        """
        pass

    def FrameToTimeFPS(self, frame, fps):
        """float = FrameToTimeFPS(float frame,float fps)
        
        Args:
            frame (float):
            fps (float):

        Returns:
            float
        """
        pass

    def GetFPS(self):
        """float = GetFPS()
        
        Returns:
            float
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def TextHintDecode(self, buf, hint):
        """integer value = TextHintDecode(string buf,hints hint)
        
        Args:
            buf (str):
            hint (hints):

        Returns:
            value (int):
        """
        pass

    def TextHintEncode(self, value, hint):
        """string = TextHintEncode(integer value,hints hint)
        
        Args:
            value (int):
            hint (hints):

        Returns:
            str
        """
        pass

    def TimeToFrame(self, time):
        """float = TimeToFrame(float time)
        
        Args:
            time (float):

        Returns:
            float
        """
        pass

    def TimeToFrameFPS(self, time, fps):
        """float = TimeToFrameFPS(float time,float fps)
        
        Args:
            time (float):
            fps (float):

        Returns:
            float
        """
        pass

    def ValueType(self, type):
        """integer valType = ValueType(string type)
        
        Args:
            type (str):

        Returns:
            valType (int):
        """
        pass


class Variation:
    """Variation"""
    def __init__(self):
        pass

    def InvalidateItem(self, item):
        """InvalidateItem(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass


class VertexFeature:
    """VertexFeature"""
    def __init__(self):
        pass

    def AllocVertex(self):
        """TableauVertex object = AllocVertex()
        
        Returns:
            object (TableauVertex):
        """
        pass

    def DataType(self, ident):
        """string typeName = DataType(string ident)
        
        Args:
            ident (str):

        Returns:
            typeName (str):
        """
        pass

    def Dimension(self, ident):
        """integer dimension = Dimension(string ident)
        
        Args:
            ident (str):

        Returns:
            dimension (int):
        """
        pass

    def Lookup(self, type, name):
        """string ident = Lookup(integer type,string name)
        
        Args:
            type (int):
            name (str):

        Returns:
            ident (str):
        """
        pass

    def Name(self, ident):
        """string name = Name(string ident)
        
        Args:
            ident (str):

        Returns:
            name (str):
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def TestCategory(self, ident, category):
        """boolean = TestCategory(string ident,string category)
        
        Args:
            ident (str):
            category (str):

        Returns:
            bool
        """
        pass

    def Type(self, ident):
        """integer type = Type(string ident)
        
        Args:
            ident (str):

        Returns:
            type (int):
        """
        pass

    def VectorType(self, ident):
        """string vecType = VectorType(string ident)
        
        Args:
            ident (str):

        Returns:
            vecType (str):
        """
        pass


class View3Dport:
    """View3Dport"""
    def __init__(self):
        pass

    def AddVirtualModel(self, vmodel):
        """AddVirtualModel(object vmodel)
        
        Args:
            vmodel (vmodel):

        Returns:
            None
        """
        pass

    def AllocGLViewport(self):
        """Unknown object = AllocGLViewport()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Count(self):
        """integer = Count()
        
        Returns:
            int
        """
        pass

    def Current(self):
        """integer = Current()
        
        Returns:
            int
        """
        pass

    def GLMaterial(self, bin, item, view):
        """Unknown object = GLMaterial(object bin,object item,object view)
        
        Args:
            bin (bin):
            item (lxu.object.Item):
            view (view):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def ImageToGLImage(self, image):
        """Unknown object = ImageToGLImage(object image)
        
        Args:
            image (lx.object.Image):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def InvalidateOverrider(self, scene, pkgName):
        """integer = InvalidateOverrider(object scene,string pkgName)
        
        Args:
            scene (scene):
            pkgName (str):

        Returns:
            int
        """
        pass

    def Mouse(self):
        """(integer,integer x,integer y) = Mouse()
        
        Returns:
            (integer,integer x,integer y)
        """
        pass

    def RemoveVirtualModel(self, vmodel):
        """RemoveVirtualModel(object vmodel)
        
        Args:
            vmodel (vmodel):

        Returns:
            None
        """
        pass

    def ScriptQuery(self):
        """Unknown object = ScriptQuery()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def SetHitUVMap(self, name):
        """SetHitUVMap(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass

    def SurfaceToViewObject(self, type, item):
        """Unknown object = SurfaceToViewObject(integer type,object item)
        
        Args:
            type (int):
            item (lxu.object.Item):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def TriGroupToViewObject(self, type, triGroup):
        """Unknown object = TriGroupToViewObject(integer type,object triGroup)
        
        Args:
            type (int):
            triGroup (triGroup):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def UpdateVirtualModel(self, vmodel):
        """UpdateVirtualModel(object vmodel)
        
        Args:
            vmodel (vmodel):

        Returns:
            None
        """
        pass

    def View(self, index):
        """Unknown object = View(integer index)
        
        Args:
            index (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass
