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


class ActionClip:
    """ActionClip"""
    def __init__(self, unknown=None):
        pass

    def Action(self, time):
        """ChannelRead object = Action(float time)
        
        Args:
            time (float):

        Returns:
            object (ChannelRead):
        """
        pass

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

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

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

    def Extents(self, layers):
        """(float timeS,float timeE) = Extents(integer layers)
        
        Args:
            layers (int):

        Returns:
            (float timeS,float timeE)
        """
        pass

    def SetActive(self, state):
        """SetActive(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def SetEnabled(self, state):
        """SetEnabled(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def SetParenting(self, group):
        """SetParenting(object group)
        
        Args:
            group (lxu.object.Item):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ActionLayerPacketTranslation:
    """ActionLayerPacketTranslation"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            int
        """
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

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

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

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ActionListener:
    """ActionListener"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AddChannel:
    """AddChannel"""
    def __init__(self, unknown=None):
        pass

    def NewChannel(self, name, type):
        """NewChannel(string name,string type)
        
        Args:
            name (str):
            type (str):

        Returns:
            None
        """
        pass

    def SetDefault(self, defFlt, defInt):
        """SetDefault(float defFlt,integer defInt)
        
        Args:
            defFlt (float):
            defInt (int):

        Returns:
            None
        """
        pass

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

    def SetDefaultVec(self, defVec):
        """SetDefaultVec(double[] defVec)
        
        Args:
            defVec (double[]):

        Returns:
            None
        """
        pass

    def SetGradient(self, inType):
        """SetGradient(string inType)
        
        Args:
            inType (str):

        Returns:
            None
        """
        pass

    def SetHint(self, hint):
        """SetHint(hints hint)
        
        Args:
            hint (hints):

        Returns:
            None
        """
        pass

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

    def SetStorage(self, stType):
        """SetStorage(string stType)
        
        Args:
            stType (str):

        Returns:
            None
        """
        pass

    def SetUserHint(self, hint):
        """SetUserHint(hints hint)
        
        Args:
            hint (hints):

        Returns:
            None
        """
        pass

    def SetVector(self, vecType):
        """SetVector(string vecType)
        
        Args:
            vecType (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AddDropAction:
    """AddDropAction"""
    def __init__(self, unknown=None):
        pass

    def AddAction(self, action, message):
        """AddAction(integer action,string message)
        
        Args:
            action (int):
            message (str):

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AdjustTool:
    """AdjustTool"""
    def __init__(self, unknown=None):
        pass

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

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

    def SetFlt(self, index, val):
        """SetFlt(integer index,float val)
        
        Args:
            index (int):
            val (float):

        Returns:
            None
        """
        pass

    def SetInt(self, index, val):
        """SetInt(integer index,integer val)
        
        Args:
            index (int):
            val (int):

        Returns:
            None
        """
        pass

    def SetString(self, index, val):
        """SetString(integer index,string val)
        
        Args:
            index (int):
            val (str):

        Returns:
            None
        """
        pass

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

    def Value(self, index, val):
        """Value(integer index,object val)
        
        Args:
            index (int):
            val (val):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AnimListener:
    """AnimListener"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AppActiveListener:
    """AppActiveListener"""
    def __init__(self, unknown=None):
        pass

    def IsNowActive(self, isActive):
        """IsNowActive(integer isActive)
        
        Args:
            isActive (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AsyncMonitorInfo:
    """AsyncMonitorInfo"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

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

    def OverallProgress(self):
        """float progress = OverallProgress()
        
        Returns:
            progress (float):
        """
        pass

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

    def Progress(self):
        """float progress = Progress()
        
        Returns:
            progress (float):
        """
        pass

    def System(self):
        """string system = System()
        
        Returns:
            system (str):
        """
        pass

    def Title(self):
        """string title = Title()
        
        Returns:
            title (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AsyncMonitorSystem:
    """AsyncMonitorSystem"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AttrSequence:
    """AttrSequence"""
    def __init__(self, unknown=None):
        pass

    def Float(self, name, value):
        """Float(string name,float value)
        
        Args:
            name (str):
            value (float):

        Returns:
            None
        """
        pass

    def HaulingOverride(self, name, value):
        """HaulingOverride(string name,string value)
        
        Args:
            name (str):
            value (str):

        Returns:
            None
        """
        pass

    def Integer(self, name, value):
        """Integer(string name,integer value)
        
        Args:
            name (str):
            value (int):

        Returns:
            None
        """
        pass

    def String(self, name, value):
        """String(string name,string value)
        
        Args:
            name (str):
            value (str):

        Returns:
            None
        """
        pass

    def Value(self, name, value):
        """Value(string name,object value)
        
        Args:
            name (str):
            value (value):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Attributes:
    """Attributes"""
    def __init__(self, unknown=None):
        pass

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

    def GetFlt(self, index):
        """float val = GetFlt(integer index)
        
        Args:
            index (int):

        Returns:
            val (float):
        """
        pass

    def GetInt(self, index):
        """integer val = GetInt(integer index)
        
        Args:
            index (int):

        Returns:
            val (int):
        """
        pass

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

        Returns:
            str
        """
        pass

    def Hints(self, index):
        """hints = Hints(integer index)
        
        Args:
            index (int):

        Returns:
            hints
        """
        pass

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

        Returns:
            index (int):
        """
        pass

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

        Returns:
            name (str):
        """
        pass

    def SetFlt(self, index, val):
        """SetFlt(integer index,float val)
        
        Args:
            index (int):
            val (float):

        Returns:
            None
        """
        pass

    def SetInt(self, index, val):
        """SetInt(integer index,integer val)
        
        Args:
            index (int):
            val (int):

        Returns:
            None
        """
        pass

    def SetString(self, index, val):
        """SetString(integer index,string val)
        
        Args:
            index (int):
            val (str):

        Returns:
            None
        """
        pass

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

        Returns:
            type (int):
        """
        pass

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

        Returns:
            tname (str):
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AttributesUI:
    """AttributesUI"""
    def __init__(self, unknown=None):
        pass

    def DisableMsg(self, index, message):
        """DisableMsg(integer index,object message)
        
        Args:
            index (int):
            message (message):

        Returns:
            None
        """
        pass

    def UIHints(self, index, hints):
        """UIHints(integer index,object hints)
        
        Args:
            index (int):
            hints (hints):

        Returns:
            None
        """
        pass

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

        Returns:
            object (UIValueHints):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Audio:
    """Audio"""
    def __init__(self, unknown=None):
        pass

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

    def Data(self):
        """data[] = Data()
        
        Returns:
            data[]
        """
        pass

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

    def Filename(self):
        """string = Filename()
        
        Returns:
            str
        """
        pass

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

    def Read(self, buff):
        """(integer frames,integer eof) = Read(data[] buff)
        
        Args:
            buff (data[]):

        Returns:
            (integer frames,integer eof)
        """
        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 Seek(self, frame):
        """Seek(integer frame)
        
        Args:
            frame (int):

        Returns:
            None
        """
        pass

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

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AudioDevice:
    """AudioDevice"""
    def __init__(self, unknown=None):
        pass

    def Handle(self, audio):
        """AudioHandle object = Handle(object audio)
        
        Args:
            audio (audio):

        Returns:
            object (AudioHandle):
        """
        pass

    def PlayFile(self, filePath):
        """PlayFile(string filePath)
        
        Args:
            filePath (str):

        Returns:
            None
        """
        pass

    def PlayRange(self, audio, start, end, volume, pitch):
        """PlayRange(object audio,float start,float end,float volume,float pitch)
        
        Args:
            audio (audio):
            start (float):
            end (float):
            volume (float):
            pitch (float):

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AudioHandle:
    """AudioHandle"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

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

    def Play(self, forward):
        """Play(integer forward)
        
        Args:
            forward (int):

        Returns:
            None
        """
        pass

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

    def SetLoop(self, loop):
        """SetLoop(integer loop)
        
        Args:
            loop (int):

        Returns:
            None
        """
        pass

    def SetOffset(self, offset):
        """SetOffset(float offset)
        
        Args:
            offset (float):

        Returns:
            None
        """
        pass

    def SetPitch(self, pitch):
        """SetPitch(float pitch)
        
        Args:
            pitch (float):

        Returns:
            None
        """
        pass

    def SetVolume(self, volume):
        """SetVolume(float volume)
        
        Args:
            volume (float):

        Returns:
            None
        """
        pass

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AudioLoaderTarget:
    """AudioLoaderTarget"""
    def __init__(self, unknown=None):
        pass

    def SetChannels(self, channels):
        """SetChannels(integer channels)
        
        Args:
            channels (int):

        Returns:
            None
        """
        pass

    def SetFrequency(self, frequency):
        """SetFrequency(integer frequency)
        
        Args:
            frequency (int):

        Returns:
            None
        """
        pass

    def SetSamples(self, samples):
        """SetSamples(integer samples)
        
        Args:
            samples (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AudioWrite:
    """AudioWrite"""
    def __init__(self, unknown=None):
        pass

    def SetDuration(self, duration):
        """SetDuration(float duration)
        
        Args:
            duration (float):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetStart(self, start):
        """SetStart(float start)
        
        Args:
            start (float):

        Returns:
            None
        """
        pass

    def Write(self, data):
        """integer frames = Write(data[] data)
        
        Args:
            data (data[]):

        Returns:
            frames (int):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class AutoSaveListener:
    """AutoSaveListener"""
    def __init__(self, unknown=None):
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class BagGenerator:
    """BagGenerator"""
    def __init__(self, unknown=None):
        pass

    def Dispose(self, data):
        """Dispose(pointer data)
        
        Args:
            data (int):

        Returns:
            None
        """
        pass

    def Generate(self, data, cloneMe):
        """pointer = Generate(pointer data,pointer cloneMe)
        
        Args:
            data (int):
            cloneMe (int):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class BasePathAddDest:
    """BasePathAddDest"""
    def __init__(self, unknown=None):
        pass

    def AddBasePath(self, setName, path):
        """AddBasePath(string setName,string path)
        
        Args:
            setName (str):
            path (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class BlockRead:
    """BlockRead"""
    def __init__(self, unknown=None):
        pass

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

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

    def FindBlock(self, head, flags):
        """integer blkId = FindBlock(blocks head,integer flags)
        
        Args:
            head (blocks):
            flags (int):

        Returns:
            blkId (int):
        """
        pass

    def ReadFP(self, count):
        """(float data,integer ocount) = ReadFP(integer count)
        
        Args:
            count (int):

        Returns:
            (float data,integer ocount)
        """
        pass

    def ReadFP8(self, count):
        """(float data,integer ocount) = ReadFP8(integer count)
        
        Args:
            count (int):

        Returns:
            (float data,integer ocount)
        """
        pass

    def ReadI1(self, data, count):
        """integer ocount = ReadI1(byte[] data,integer count)
        
        Args:
            data (byte[]):
            count (int):

        Returns:
            ocount (int):
        """
        pass

    def ReadI4(self, data, count):
        """integer ocount = ReadI4(int[] data,integer count)
        
        Args:
            data (int[]):
            count (int):

        Returns:
            ocount (int):
        """
        pass

    def ReadIDCode(self, list):
        """integer idCode = ReadIDCode(blocks list)
        
        Args:
            list (blocks):

        Returns:
            idCode (int):
        """
        pass

    def ReadString(self, buf, max, flags):
        """integer ocount = ReadString(byte[] buf,integer max,integer flags)
        
        Args:
            buf (byte[]):
            max (int):
            flags (int):

        Returns:
            ocount (int):
        """
        pass

    def ReadU2(self, count):
        """(integer data,integer ocount) = ReadU2(integer count)
        
        Args:
            count (int):

        Returns:
            (integer data,integer ocount)
        """
        pass

    def ReadU4(self, count):
        """(integer data,integer ocount) = ReadU4(integer count)
        
        Args:
            count (int):

        Returns:
            (integer data,integer ocount)
        """
        pass

    def ReadVX(self, count):
        """(integer data,integer ocount) = ReadVX(integer count)
        
        Args:
            count (int):

        Returns:
            (integer data,integer ocount)
        """
        pass

    def SetMiniBlockHeight(self, mini):
        """SetMiniBlockHeight(integer mini)
        
        Args:
            mini (int):

        Returns:
            None
        """
        pass

    def SetSourceEncoding(self, encoding):
        """SetSourceEncoding(integer encoding)
        
        Args:
            encoding (int):

        Returns:
            None
        """
        pass

    def SetTargetEncoding(self, encoding):
        """SetTargetEncoding(integer encoding)
        
        Args:
            encoding (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class BlockStore:
    """BlockStore"""
    def __init__(self, unknown=None):
        pass

    def AllocBookmark(self):
        """id loc = AllocBookmark()
        
        Returns:
            loc (id):
        """
        pass

    def ByIndex(self, type, index, parent):
        """ByIndex(integer type,integer index,id parent)
        
        Args:
            type (int):
            index (int):
            parent (id):

        Returns:
            None
        """
        pass

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

        Returns:
            count (int):
        """
        pass

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

    def Ident(self):
        """string id = Ident()
        
        Returns:
            id (str):
        """
        pass

    def Lookup(self, type, id, parent):
        """Lookup(integer type,string id,id parent)
        
        Args:
            type (int):
            id (str):
            parent (id):

        Returns:
            None
        """
        pass

    def ReadBlock(self, buf, offset, size):
        """ReadBlock(pointer buf,integer offset,integer size)
        
        Args:
            buf (int):
            offset (int):
            size (int):

        Returns:
            None
        """
        pass

    def RestoreBookmark(self, loc):
        """RestoreBookmark(id loc)
        
        Args:
            loc (id):

        Returns:
            None
        """
        pass

    def SaveBookmark(self, loc):
        """SaveBookmark(id loc)
        
        Args:
            loc (id):

        Returns:
            None
        """
        pass

    def Stack(self, operation):
        """Stack(integer operation)
        
        Args:
            operation (int):

        Returns:
            None
        """
        pass

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

    def WriteBlock(self, buf, offset, size):
        """WriteBlock(data[] buf,integer offset,integer size)
        
        Args:
            buf (data[]):
            offset (int):
            size (int):

        Returns:
            None
        """
        pass

    def WriteSize(self, size):
        """WriteSize(integer size)
        
        Args:
            size (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class BlockWrite:
    """BlockWrite"""
    def __init__(self, unknown=None):
        pass

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

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

    def SetSourceEncoding(self, encoding):
        """SetSourceEncoding(integer encoding)
        
        Args:
            encoding (int):

        Returns:
            None
        """
        pass

    def SetTargetEncoding(self, encoding):
        """SetTargetEncoding(integer encoding)
        
        Args:
            encoding (int):

        Returns:
            None
        """
        pass

    def WriteBlock(self, head, flags):
        """WriteBlock(blocks head,integer flags)
        
        Args:
            head (blocks):
            flags (int):

        Returns:
            None
        """
        pass

    def WriteFP(self, data, count):
        """WriteFP(float[] data,integer count)
        
        Args:
            data (float[]):
            count (int):

        Returns:
            None
        """
        pass

    def WriteFP8(self, data, count):
        """WriteFP8(double[] data,integer count)
        
        Args:
            data (double[]):
            count (int):

        Returns:
            None
        """
        pass

    def WriteI1(self, data, count):
        """WriteI1(string data,integer count)
        
        Args:
            data (str):
            count (int):

        Returns:
            None
        """
        pass

    def WriteI4(self, data, count):
        """WriteI4(int[] data,integer count)
        
        Args:
            data (int[]):
            count (int):

        Returns:
            None
        """
        pass

    def WriteIDCode(self, ident):
        """WriteIDCode(blocks ident)
        
        Args:
            ident (blocks):

        Returns:
            None
        """
        pass

    def WriteString(self, str):
        """WriteString(string str)
        
        Args:
            str (str):

        Returns:
            None
        """
        pass

    def WriteU4(self, data, count):
        """WriteU4(unsigned[] data,integer count)
        
        Args:
            data (unsigned[]):
            count (int):

        Returns:
            None
        """
        pass

    def WriteVX(self, data, count):
        """WriteVX(unsigned[] data,integer count)
        
        Args:
            data (unsigned[]):
            count (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Buffer:
    """Buffer"""
    def __init__(self, unknown=None):
        pass

    def Clear(self, x, y):
        """Clear(integer x,integer y)
        
        Args:
            x (int):
            y (int):

        Returns:
            None
        """
        pass

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

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

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

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

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

    def GetImageTileTree(self):
        """id = GetImageTileTree()
        
        Returns:
            id
        """
        pass

    def GetSize(self):
        """(integer width,integer height) = GetSize()
        
        Returns:
            (integer width,integer height)
        """
        pass

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

    def Line(self, y):
        """pointer = Line(integer y)
        
        Args:
            y (int):

        Returns:
            int
        """
        pass

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

    def Pixel(self, x, y):
        """pointer = Pixel(integer x,integer y)
        
        Args:
            x (int):
            y (int):

        Returns:
            int
        """
        pass

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

    def SetEyeSide(self, eyeSide):
        """SetEyeSide(integer eyeSide)
        
        Args:
            eyeSide (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetSize(self, width, height, writeBucketsToDisk, isStereo):
        """SetSize(integer width,integer height,integer writeBucketsToDisk,integer isStereo)
        
        Args:
            width (int):
            height (int):
            writeBucketsToDisk (int):
            isStereo (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CacheData:
    """CacheData"""
    def __init__(self, unknown=None):
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CenterPacketTranslation:
    """CenterPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

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

    def Packet(self, item):
        """pointer = Packet(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelDest:
    """ChannelDest"""
    def __init__(self, unknown=None):
        pass

    def Channel(self):
        """Value object = Channel()
        
        Returns:
            object (Value):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelDropPreview:
    """ChannelDropPreview"""
    def __init__(self, unknown=None):
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelGraph:
    """ChannelGraph"""
    def __init__(self, unknown=None):
        pass

    def AddLink(self, from_obj, fromChan, to_obj, toChan):
        """AddLink(object from_obj,integer fromChan,object to_obj,integer toChan)
        
        Args:
            from_obj (from_obj):
            fromChan (int):
            to_obj (to_obj):
            toChan (int):

        Returns:
            None
        """
        pass

    def DeleteLink(self, from_obj, fromChan, to_obj, toChan):
        """DeleteLink(object from_obj,integer fromChan,object to_obj,integer toChan)
        
        Args:
            from_obj (from_obj):
            fromChan (int):
            to_obj (to_obj):
            toChan (int):

        Returns:
            None
        """
        pass

    def FwdByIndex(self, item, channel, index):
        """(Item object,integer objChan) = FwdByIndex(object item,integer channel,integer index)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            index (int):

        Returns:
            (Item object,integer objChan)
        """
        pass

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

        Returns:
            count (int):
        """
        pass

    def RevByIndex(self, item, channel, index):
        """(Item object,integer objChan) = RevByIndex(object item,integer channel,integer index)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            index (int):

        Returns:
            (Item object,integer objChan)
        """
        pass

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

        Returns:
            count (int):
        """
        pass

    def SetLink(self, from_obj, fromChan, fromIndex, to_obj, toChan, toIndex):
        """SetLink(object from_obj,integer fromChan,integer fromIndex,object to_obj,integer toChan,integer toIndex)
        
        Args:
            from_obj (from_obj):
            fromChan (int):
            fromIndex (int):
            to_obj (to_obj):
            toChan (int):
            toIndex (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelModSetup:
    """ChannelModSetup"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

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

    def ReadArray(self, name):
        """ValueArray object = ReadArray(string name)
        
        Args:
            name (str):

        Returns:
            object (ValueArray):
        """
        pass

    def ReadTimeValue(self):
        """Value object = ReadTimeValue()
        
        Returns:
            object (Value):
        """
        pass

    def ReadValue(self, name):
        """Value object = ReadValue(string name)
        
        Args:
            name (str):

        Returns:
            object (Value):
        """
        pass

    def WriteValue(self, name):
        """Value object = WriteValue(string name)
        
        Args:
            name (str):

        Returns:
            object (Value):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelModifier:
    """ChannelModifier"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

    def InputCount(self, index):
        """integer nInputs = InputCount(integer index)
        
        Args:
            index (int):

        Returns:
            nInputs (int):
        """
        pass

    def OutputCount(self, index):
        """integer nOutputs = OutputCount(integer index)
        
        Args:
            index (int):

        Returns:
            nOutputs (int):
        """
        pass

    def ReadInputAngle(self, attr, inputIndex):
        """float dVal = ReadInputAngle(object attr,integer inputIndex)
        
        Args:
            attr (attr):
            inputIndex (int):

        Returns:
            dVal (float):
        """
        pass

    def ReadInputFloat(self, attr, inputIndex):
        """float dVal = ReadInputFloat(object attr,integer inputIndex)
        
        Args:
            attr (attr):
            inputIndex (int):

        Returns:
            dVal (float):
        """
        pass

    def ReadInputFloatByIndex(self, attr, inputIndex, linkIndex):
        """float dVal = ReadInputFloatByIndex(object attr,integer inputIndex,integer linkIndex)
        
        Args:
            attr (attr):
            inputIndex (int):
            linkIndex (int):

        Returns:
            dVal (float):
        """
        pass

    def ReadInputInt(self, attr, inputIndex):
        """integer iVal = ReadInputInt(object attr,integer inputIndex)
        
        Args:
            attr (attr):
            inputIndex (int):

        Returns:
            iVal (int):
        """
        pass

    def ReadInputIntByIndex(self, attr, inputIndex, linkIndex):
        """integer iVal = ReadInputIntByIndex(object attr,integer inputIndex,integer linkIndex)
        
        Args:
            attr (attr):
            inputIndex (int):
            linkIndex (int):

        Returns:
            iVal (int):
        """
        pass

    def WriteOutputFloat(self, attr, outputIndex, dVal):
        """WriteOutputFloat(object attr,integer outputIndex,float dVal)
        
        Args:
            attr (attr):
            outputIndex (int):
            dVal (float):

        Returns:
            None
        """
        pass

    def WriteOutputInt(self, attr, outputIndex, iVal):
        """WriteOutputInt(object attr,integer outputIndex,integer iVal)
        
        Args:
            attr (attr):
            outputIndex (int):
            iVal (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelPacketTranslation:
    """ChannelPacketTranslation"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            int
        """
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

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

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

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelRead:
    """ChannelRead"""
    def __init__(self, unknown=None):
        pass

    def BakedSamples(self, item, channel):
        """(float firstSample,float spsRate,ValueArray object) = BakedSamples(object item,integer channel)
        
        Args:
            item (lxu.object.Item):
            channel (int):

        Returns:
            (float firstSample,float spsRate,ValueArray object)
        """
        pass

    def Double(self, item, channel):
        """float value = Double(object item,integer channel)
        
        Args:
            item (lxu.object.Item):
            channel (int):

        Returns:
            value (float):
        """
        pass

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

        Returns:
            str
        """
        pass

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

        Returns:
            object (Envelope):
        """
        pass

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

        Returns:
            value (int):
        """
        pass

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

        Returns:
            int
        """
        pass

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

        Returns:
            bool
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            value (str):
        """
        pass

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

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

        Returns:
            type (int):
        """
        pass

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

        Returns:
            typeName (str):
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelUI:
    """ChannelUI"""
    def __init__(self, unknown=None):
        pass

    def Cookie(self, channelName, requestedFor):
        """string cookie = Cookie(string channelName,string requestedFor)
        
        Args:
            channelName (str):
            requestedFor (str):

        Returns:
            cookie (str):
        """
        pass

    def DependencyByIndex(self, channelName, index):
        """(integer depItemType,string depChannelName) = DependencyByIndex(string channelName,integer index)
        
        Args:
            channelName (str):
            index (int):

        Returns:
            (integer depItemType,string depChannelName)
        """
        pass

    def DependencyByIndexName(self, channelName, index):
        """(string depItemTypeName,string depChannelName) = DependencyByIndexName(string channelName,integer index)
        
        Args:
            channelName (str):
            index (int):

        Returns:
            (string depItemTypeName,string depChannelName)
        """
        pass

    def DependencyCount(self, channelName):
        """integer count = DependencyCount(string channelName)
        
        Args:
            channelName (str):

        Returns:
            count (int):
        """
        pass

    def Enabled(self, channelName, msg, item, chanRead):
        """Enabled(string channelName,object msg,object item,object chanRead)
        
        Args:
            channelName (str):
            msg (msg):
            item (lxu.object.Item):
            chanRead (chanRead):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def ItemIcon(self, item):
        """string icon = ItemIcon(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            icon (str):
        """
        pass

    def UIHints(self, channelName, hints):
        """UIHints(string channelName,object hints)
        
        Args:
            channelName (str):
            hints (hints):

        Returns:
            None
        """
        pass

    def UIValueHints(self, channelName):
        """UIValueHints object = UIValueHints(string channelName)
        
        Args:
            channelName (str):

        Returns:
            object (UIValueHints):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ChannelWrite:
    """ChannelWrite"""
    def __init__(self, unknown=None):
        pass

    def BakeSamples(self, item, channel, firstSample, spsRate):
        """ValueArray object = BakeSamples(object item,integer channel,float firstSample,float spsRate)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            firstSample (float):
            spsRate (float):

        Returns:
            object (ValueArray):
        """
        pass

    def Double(self, item, channel, value):
        """Double(object item,integer channel,float value)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            value (float):

        Returns:
            None
        """
        pass

    def DoubleKey(self, item, channel, value, create):
        """DoubleKey(object item,integer channel,float value,integer create)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            value (float):
            create (int):

        Returns:
            None
        """
        pass

    def EncodedInt(self, item, channel, value):
        """EncodedInt(object item,integer channel,string value)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            value (str):

        Returns:
            None
        """
        pass

    def EncodedIntKey(self, item, channel, value):
        """EncodedIntKey(object item,integer channel,string value)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            value (str):

        Returns:
            None
        """
        pass

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

        Returns:
            object (Envelope):
        """
        pass

    def Integer(self, item, channel, value):
        """Integer(object item,integer channel,integer value)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            value (int):

        Returns:
            None
        """
        pass

    def IntegerKey(self, item, channel, value, create):
        """IntegerKey(object item,integer channel,integer value,integer create)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            value (int):
            create (int):

        Returns:
            None
        """
        pass

    def SetState(self, item, channel, state):
        """SetState(object item,integer channel,integer state)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            state (int):

        Returns:
            None
        """
        pass

    def String(self, item, channel, value):
        """String(object item,integer channel,string value)
        
        Args:
            item (lxu.object.Item):
            channel (int):
            value (str):

        Returns:
            None
        """
        pass

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

        Returns:
            type (int):
        """
        pass

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

        Returns:
            typeName (str):
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ClipDest:
    """ClipDest"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CmdSysListener:
    """CmdSysListener"""
    def __init__(self, unknown=None):
        pass

    def AliasAdded(self, name, isOverride):
        """AliasAdded(string name,integer isOverride)
        
        Args:
            name (str):
            isOverride (int):

        Returns:
            None
        """
        pass

    def AliasRemoved(self, name, isOverride):
        """AliasRemoved(string name,integer isOverride)
        
        Args:
            name (str):
            isOverride (int):

        Returns:
            None
        """
        pass

    def BlockBegin(self, block, isSandboxed):
        """BlockBegin(object block,integer isSandboxed)
        
        Args:
            block (block):
            isSandboxed (int):

        Returns:
            None
        """
        pass

    def BlockEnd(self, block, isSandboxed, wasDiscarded):
        """BlockEnd(object block,integer isSandboxed,integer wasDiscarded)
        
        Args:
            block (block):
            isSandboxed (int):
            wasDiscarded (int):

        Returns:
            None
        """
        pass

    def BlockEndedPostMode(self, name, isSandboxed):
        """BlockEndedPostMode(string name,integer isSandboxed)
        
        Args:
            name (str):
            isSandboxed (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def ExecutePost(self, cmd, isSandboxed, isPostCmd):
        """ExecutePost(object cmd,integer isSandboxed,integer isPostCmd)
        
        Args:
            cmd (cmd):
            isSandboxed (int):
            isPostCmd (int):

        Returns:
            None
        """
        pass

    def ExecutePre(self, cmd, type, isSandboxed, isPostCmd):
        """ExecutePre(object cmd,integer type,integer isSandboxed,integer isPostCmd)
        
        Args:
            cmd (cmd):
            type (int):
            isSandboxed (int):
            isPostCmd (int):

        Returns:
            None
        """
        pass

    def ExecuteResult(self, cmd, type, isSandboxed, isPostCmd, wasSuccessful):
        """ExecuteResult(object cmd,integer type,integer isSandboxed,integer isPostCmd,integer wasSuccessful)
        
        Args:
            cmd (cmd):
            type (int):
            isSandboxed (int):
            isPostCmd (int):
            wasSuccessful (int):

        Returns:
            None
        """
        pass

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

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

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

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

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

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

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

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

    def UndoLockout(self, isLockedOut):
        """UndoLockout(integer isLockedOut)
        
        Args:
            isLockedOut (int):

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Color:
    """Color"""
    def __init__(self, unknown=None):
        pass

    def Alpha(self):
        """float alpha = Alpha()
        
        Returns:
            alpha (float):
        """
        pass

    def Color(self):
        """float color = Color()
        
        Returns:
            color (float):
        """
        pass

    def ColorInModelSpace(self):
        """float vec = ColorInModelSpace()
        
        Returns:
            vec (float):
        """
        pass

    def ColorModel(self):
        """string model = ColorModel()
        
        Returns:
            model (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ColorDialog:
    """ColorDialog"""
    def __init__(self, unknown=None):
        pass

    def DoDialog(self, title, stops, gamma):
        """float rgb = DoDialog(string title,float stops,float gamma)
        
        Args:
            title (str):
            stops (float):
            gamma (float):

        Returns:
            rgb (float):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ColorMapping:
    """ColorMapping"""
    def __init__(self, unknown=None):
        pass

    def FromLinear(self, linearValues, length):
        """vector targetValues = FromLinear(vector linearValues,integer length)
        
        Args:
            linearValues (tuple):
            length (int):

        Returns:
            targetValues (tuple):
        """
        pass

    def FromLinearFast(self, length):
        """float buf = FromLinearFast(integer length)
        
        Args:
            length (int):

        Returns:
            buf (float):
        """
        pass

    def GetCMServerName(self):
        """string = GetCMServerName()
        
        Returns:
            str
        """
        pass

    def GetName(self):
        """string = GetName()
        
        Returns:
            str
        """
        pass

    def Setup(self, toLinear):
        """Setup(integer toLinear)
        
        Args:
            toLinear (int):

        Returns:
            None
        """
        pass

    def ToLinear(self, sourceValues, length):
        """vector linearValues = ToLinear(vector sourceValues,integer length)
        
        Args:
            sourceValues (tuple):
            length (int):

        Returns:
            linearValues (tuple):
        """
        pass

    def ToLinearFast(self, length):
        """float buf = ToLinearFast(integer length)
        
        Args:
            length (int):

        Returns:
            buf (float):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ColorMappingModule:
    """ColorMappingModule"""
    def __init__(self, unknown=None):
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ColorModel:
    """ColorModel"""
    def __init__(self, unknown=None):
        pass

    def CanSliceBeReused(self, xAxis, yAxis, oldVec, newVec):
        """boolean = CanSliceBeReused(integer xAxis,integer yAxis,float[] oldVec,float[] newVec)
        
        Args:
            xAxis (int):
            yAxis (int):
            oldVec (float[]):
            newVec (float[]):

        Returns:
            bool
        """
        pass

    def ComponentRange(self, component):
        """(float min,float max) = ComponentRange(integer component)
        
        Args:
            component (int):

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

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

        Returns:
            type (str):
        """
        pass

    def DrawSlice(self, image, xAxis, yAxis, vec):
        """DrawSlice(object image,integer xAxis,integer yAxis,float[] vec)
        
        Args:
            image (lx.object.Image):
            xAxis (int):
            yAxis (int):
            vec (float[]):

        Returns:
            None
        """
        pass

    def DrawSliceMarker(self, image, xAxis, yAxis, downVec, vec):
        """DrawSliceMarker(object image,integer xAxis,integer yAxis,float[] downVec,float[] vec)
        
        Args:
            image (lx.object.Image):
            xAxis (int):
            yAxis (int):
            downVec (float[]):
            vec (float[]):

        Returns:
            None
        """
        pass

    def FromRGB(self, rgb, vector):
        """FromRGB(float[] rgb,float[] vector)
        
        Args:
            rgb (float[]):
            vector (float[]):

        Returns:
            None
        """
        pass

    def FromSlicePos(self, xAxis, yAxis, imgW, imgH, imgX, imgY, downVec, vec):
        """FromSlicePos(integer xAxis,integer yAxis,integer imgW,integer imgH,integer imgX,integer imgY,float[] downVec,float[] vec)
        
        Args:
            xAxis (int):
            yAxis (int):
            imgW (int):
            imgH (int):
            imgX (int):
            imgY (int):
            downVec (float[]):
            vec (float[]):

        Returns:
            None
        """
        pass

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

    def StripBaseVector(self, axis, dynamic, vec):
        """StripBaseVector(integer axis,integer dynamic,float[] vec)
        
        Args:
            axis (int):
            dynamic (int):
            vec (float[]):

        Returns:
            None
        """
        pass

    def ToRGB(self, vector, rgb):
        """ToRGB(float[] vector,float[] rgb)
        
        Args:
            vector (float[]):
            rgb (float[]):

        Returns:
            None
        """
        pass

    def ToSlicePos(self, xAxis, yAxis, imgW, imgH, vec):
        """(integer imgX,integer imgY) = ToSlicePos(integer xAxis,integer yAxis,integer imgW,integer imgH,float[] vec)
        
        Args:
            xAxis (int):
            yAxis (int):
            imgW (int):
            imgH (int):
            vec (float[]):

        Returns:
            (integer imgX,integer imgY)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ColorPreDest:
    """ColorPreDest"""
    def __init__(self, unknown=None):
        pass

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

    def SetColor(self, rgb):
        """SetColor(vector rgb)
        
        Args:
            rgb (tuple):

        Returns:
            None
        """
        pass

    def SetColorModel(self, name, vec):
        """SetColorModel(string name,double[] vec)
        
        Args:
            name (str):
            vec (double[]):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Command:
    """Command"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            desc (str):
        """
        pass

    def ArgEnable(self, arg):
        """ArgEnable(integer arg)
        
        Args:
            arg (int):

        Returns:
            None
        """
        pass

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

        Returns:
            example (str):
        """
        pass

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

        Returns:
            flags (int):
        """
        pass

    def ArgOptionDesc(self, index, optIndex):
        """string desc = ArgOptionDesc(integer index,integer optIndex)
        
        Args:
            index (int):
            optIndex (int):

        Returns:
            desc (str):
        """
        pass

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

        Returns:
            userName (str):
        """
        pass

    def ArgParseString(self, argIndex, argString):
        """ArgParseString(integer argIndex,string argString)
        
        Args:
            argIndex (int):
            argString (str):

        Returns:
            None
        """
        pass

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

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

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

        Returns:
            type (str):
        """
        pass

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

        Returns:
            desc (str):
        """
        pass

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

        Returns:
            userName (str):
        """
        pass

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

        Returns:
            userName (str):
        """
        pass

    def ButtonName(self):
        """string buttonName = ButtonName()
        
        Returns:
            buttonName (str):
        """
        pass

    def ContainedEnable(self):
        """integer types = ContainedEnable()
        
        Returns:
            types (int):
        """
        pass

    def Copy(self, sourceCommand):
        """Copy(object sourceCommand)
        
        Args:
            sourceCommand (sourceCommand):

        Returns:
            None
        """
        pass

    def Desc(self):
        """string desc = Desc()
        
        Returns:
            desc (str):
        """
        pass

    def DialogArgChange(self, arg):
        """DialogArgChange(integer arg)
        
        Args:
            arg (int):

        Returns:
            None
        """
        pass

    def DialogFormatting(self):
        """string formatting = DialogFormatting()
        
        Returns:
            formatting (str):
        """
        pass

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

    def Enable(self, msg):
        """Enable(object msg)
        
        Args:
            msg (msg):

        Returns:
            None
        """
        pass

    def Example(self):
        """string example = Example()
        
        Returns:
            example (str):
        """
        pass

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

        Returns:
            None
        """
        pass

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

    def Help(self):
        """string help = Help()
        
        Returns:
            help (str):
        """
        pass

    def Icon(self):
        """string iconNames = Icon()
        
        Returns:
            iconNames (str):
        """
        pass

    def IconImage(self, w, h):
        """Image object = IconImage(integer w,integer h)
        
        Args:
            w (int):
            h (int):

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

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

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

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

    def NotifyAddClient(self, argument, object):
        """NotifyAddClient(integer argument,object object)
        
        Args:
            argument (int):
            object (object):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

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

    def PostExecHints(self):
        """integer hints = PostExecHints()
        
        Returns:
            hints (int):
        """
        pass

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

    def Query(self, index, vaQuery):
        """Query(integer index,object vaQuery)
        
        Args:
            index (int):
            vaQuery (vaQuery):

        Returns:
            None
        """
        pass

    def SandboxGUID(self):
        """string guid = SandboxGUID()
        
        Returns:
            guid (str):
        """
        pass

    def Tag(self):
        """integer tag = Tag()
        
        Returns:
            tag (int):
        """
        pass

    def ToggleArg(self):
        """(integer index,Value object,integer typeID,string typeName) = ToggleArg()
        
        Returns:
            (integer index,Value object,integer typeID,string typeName)
        """
        pass

    def Tooltip(self):
        """string tooltip = Tooltip()
        
        Returns:
            tooltip (str):
        """
        pass

    def UserName(self):
        """string userName = UserName()
        
        Returns:
            userName (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CommandDBHelp:
    """CommandDBHelp"""
    def __init__(self, unknown=None):
        pass

    def DBHelp(self):
        """string dbhelp = DBHelp()
        
        Returns:
            dbhelp (str):
        """
        pass

    def DBTooltip(self):
        """string dbtooltip = DBTooltip()
        
        Returns:
            dbtooltip (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CommandEvent:
    """CommandEvent"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CompShader:
    """CompShader"""
    def __init__(self, unknown=None):
        pass

    def Cleanup(self, data):
        """Cleanup(pointer data)
        
        Args:
            data (int):

        Returns:
            None
        """
        pass

    def CustomPacket(self):
        """string packet = CustomPacket()
        
        Returns:
            packet (str):
        """
        pass

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

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

        Returns:
            None
        """
        pass

    def SetOpaque(self):
        """integer opaque = SetOpaque()
        
        Returns:
            opaque (int):
        """
        pass

    def SetupChannels(self, addChan):
        """SetupChannels(object addChan)
        
        Args:
            addChan (addChan):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Curve:
    """Curve"""
    def __init__(self, unknown=None):
        pass

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

    def Closest(self, probe):
        """(float param,vector pos,vector norm) = Closest(vector probe)
        
        Args:
            probe (tuple):

        Returns:
            (float param,vector pos,vector norm)
        """
        pass

    def Curvature(self):
        """float curv = Curvature()
        
        Returns:
            curv (float):
        """
        pass

    def GetBBox(self):
        """bounds bbox = GetBBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def GuideCurveNormal(self, other):
        """vector normal = GuideCurveNormal(object other)
        
        Args:
            other (other):

        Returns:
            normal (tuple):
        """
        pass

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

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

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

    def MeshNormal(self, meshObj):
        """(matrix xfrm,vector normal) = MeshNormal(object meshObj)
        
        Args:
            meshObj (meshObj):

        Returns:
            (matrix xfrm,vector normal)
        """
        pass

    def Normal(self):
        """vector normal = Normal()
        
        Returns:
            normal (tuple):
        """
        pass

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

    def Position(self):
        """vector pos = Position()
        
        Returns:
            pos (tuple):
        """
        pass

    def SetLenFraction(self, frac):
        """SetLenFraction(float frac)
        
        Args:
            frac (float):

        Returns:
            None
        """
        pass

    def SetParam(self, param):
        """SetParam(float param)
        
        Args:
            param (float):

        Returns:
            None
        """
        pass

    def SplineByIndex(self, index):
        """(vector b0,vector b1,vector b2,vector b3) = SplineByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (vector b0,vector b1,vector b2,vector b3)
        """
        pass

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

    def SplineLengthByIndex(self, index):
        """float length = SplineLengthByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            length (float):
        """
        pass

    def Tangent(self):
        """vector tan = Tangent()
        
        Returns:
            tan (tuple):
        """
        pass

    def WalkByAngle(self, start, end, angle, visitor):
        """WalkByAngle(float start,float end,float angle,object visitor)
        
        Args:
            start (float):
            end (float):
            angle (float):
            visitor (visitor):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CurveGroup:
    """CurveGroup"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            object (Curve):
        """
        pass

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

    def GetBBox(self):
        """bounds bbox = GetBBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CustomMaterial:
    """CustomMaterial"""
    def __init__(self, unknown=None):
        pass

    def Cleanup(self, data):
        """Cleanup(pointer data)
        
        Args:
            data (int):

        Returns:
            None
        """
        pass

    def CustomPacket(self):
        """string packet = CustomPacket()
        
        Returns:
            packet (str):
        """
        pass

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

    def IsSampleDriven(self):
        """(integer,integer idx) = IsSampleDriven()
        
        Returns:
            idx) ((integer,integer):
        """
        pass

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

        Returns:
            None
        """
        pass

    def LinkSampleChannels(self, nodalEtor, item):
        """integer idx = LinkSampleChannels(object nodalEtor,object item)
        
        Args:
            nodalEtor (nodalEtor):
            item (lxu.object.Item):

        Returns:
            idx (int):
        """
        pass

    def MaterialEvaluate(self, etor, vector, data):
        """integer idx = MaterialEvaluate(object etor,object vector,pointer data)
        
        Args:
            etor (etor):
            vector (tuple):
            data (int):

        Returns:
            idx (int):
        """
        pass

    def SetBump(self):
        """(float bumpAmplitude,integer clearBump) = SetBump()
        
        Returns:
            (float bumpAmplitude,integer clearBump)
        """
        pass

    def SetDisplacement(self):
        """float dispDist = SetDisplacement()
        
        Returns:
            dispDist (float):
        """
        pass

    def SetOpaque(self):
        """integer opaque = SetOpaque()
        
        Returns:
            opaque (int):
        """
        pass

    def SetSmoothing(self):
        """(float smooth,float angle,integer weighting,integer normalMethod,integer creasing) = SetSmoothing()
        
        Returns:
            (float smooth,float angle,integer weighting,integer normalMethod,integer creasing)
        """
        pass

    def SetupChannels(self, addChan):
        """SetupChannels(object addChan)
        
        Args:
            addChan (addChan):

        Returns:
            None
        """
        pass

    def UpdatePreview(self, chanIdx):
        """integer flags = UpdatePreview(integer chanIdx)
        
        Args:
            chanIdx (int):

        Returns:
            flags (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CustomPane:
    """CustomPane"""
    def __init__(self, unknown=None):
        pass

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

    def GetParent(self):
        """id handle = GetParent()
        
        Returns:
            handle (id):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class CustomView:
    """CustomView"""
    def __init__(self, unknown=None):
        pass

    def Cleanup(self, pane):
        """Cleanup(object pane)
        
        Args:
            pane (pane):

        Returns:
            None
        """
        pass

    def Init(self, pane):
        """Init(object pane)
        
        Args:
            pane (pane):

        Returns:
            None
        """
        pass

    def RestoreState(self, pane):
        """RestoreState(object pane)
        
        Args:
            pane (pane):

        Returns:
            None
        """
        pass

    def StoreState(self, pane):
        """StoreState(object pane)
        
        Args:
            pane (pane):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DTBBadgeOverride:
    """DTBBadgeOverride"""
    def __init__(self, unknown=None):
        pass

    def BadgeAction(self, entry, badge):
        """BadgeAction(object entry,integer badge)
        
        Args:
            entry (entry):
            badge (int):

        Returns:
            None
        """
        pass

    def BadgeIsAlwaysVisible(self, entry, badge):
        """boolean = BadgeIsAlwaysVisible(object entry,integer badge)
        
        Args:
            entry (entry):
            badge (int):

        Returns:
            bool
        """
        pass

    def BadgeOverride(self, entry, badge):
        """string = BadgeOverride(object entry,integer badge)
        
        Args:
            entry (entry):
            badge (int):

        Returns:
            str
        """
        pass

    def BadgeStarRatingAction(self, entry, rating):
        """BadgeStarRatingAction(object entry,integer rating)
        
        Args:
            entry (entry):
            rating (int):

        Returns:
            None
        """
        pass

    def BadgeStarRatingOverride(self, entry):
        """(integer rating,string) = BadgeStarRatingOverride(object entry)
        
        Args:
            entry (entry):

        Returns:
            rating,string) ((integer):
        """
        pass

    def BadgeTooltip(self, entry, badge):
        """string = BadgeTooltip(object entry,integer badge)
        
        Args:
            entry (entry):
            badge (int):

        Returns:
            str
        """
        pass

    def BadgesSupported(self, entry):
        """integer badges = BadgesSupported(object entry)
        
        Args:
            entry (entry):

        Returns:
            badges (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DTBDropPreview:
    """DTBDropPreview"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

    def MarkBetween(self, path, markBefore):
        """MarkBetween(string path,integer markBefore)
        
        Args:
            path (str):
            markBefore (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def MarkGridPos(self, path, x, y):
        """MarkGridPos(string path,integer x,integer y)
        
        Args:
            path (str):
            x (int):
            y (int):

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DTBGroupSortOverride:
    """DTBGroupSortOverride"""
    def __init__(self, unknown=None):
        pass

    def SetArguments(self, args):
        """SetArguments(string args)
        
        Args:
            args (str):

        Returns:
            None
        """
        pass

    def Sort(self, string1, string2):
        """integer = Sort(string string1,string string2)
        
        Args:
            string1 (str):
            string2 (str):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Deformation:
    """Deformation"""
    def __init__(self, unknown=None):
        pass

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

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

    def OffsetF(self, position, weight):
        """vector offset = OffsetF(vector position,float weight)
        
        Args:
            position (tuple):
            weight (float):

        Returns:
            offset (tuple):
        """
        pass

    def Transform(self):
        """matrix xfrm = Transform()
        
        Returns:
            xfrm (lx.object.Matrix):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Deformer:
    """Deformer"""
    def __init__(self, unknown=None):
        pass

    def Element(self):
        """(id,integer segment) = Element()
        
        Returns:
            segment) ((id,integer):
        """
        pass

    def EnumeratePartition(self, visitor, part):
        """EnumeratePartition(object visitor,integer part)
        
        Args:
            visitor (visitor):
            part (int):

        Returns:
            None
        """
        pass

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

    def Offset(self, elt, weight, pos):
        """vector offset = Offset(id elt,float weight,vector pos)
        
        Args:
            elt (id):
            weight (float):
            pos (tuple):

        Returns:
            offset (tuple):
        """
        pass

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

    def SetPartition(self, part):
        """SetPartition(integer part)
        
        Args:
            part (int):

        Returns:
            None
        """
        pass

    def Weight(self, elt, pos):
        """float = Weight(id elt,vector pos)
        
        Args:
            elt (id):
            pos (tuple):

        Returns:
            float
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirBrowserBasePathEntryDest:
    """DirBrowserBasePathEntryDest"""
    def __init__(self, unknown=None):
        pass

    def OrdinalAfter(self):
        """string ordinal = OrdinalAfter()
        
        Returns:
            ordinal (str):
        """
        pass

    def OrdinalBefore(self):
        """string ordinal = OrdinalBefore()
        
        Returns:
            ordinal (str):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirCacheEntry:
    """DirCacheEntry"""
    def __init__(self, unknown=None):
        pass

    def CachedThumbnail(self, size):
        """(integer idealW,integer idealH,Image object) = CachedThumbnail(integer size)
        
        Args:
            size (int):

        Returns:
            (integer idealW,integer idealH,Image object)
        """
        pass

    def CachedThumbnailAsync(self, size, asyncHandler):
        """(integer idealW,integer idealH,Image object) = CachedThumbnailAsync(integer size,object asyncHandler)
        
        Args:
            size (int):
            asyncHandler (asyncHandler):

        Returns:
            (integer idealW,integer idealH,Image object)
        """
        pass

    def CachedThumbnailCustom(self, w, h):
        """(integer idealW,integer idealH,Image object) = CachedThumbnailCustom(integer w,integer h)
        
        Args:
            w (int):
            h (int):

        Returns:
            (integer idealW,integer idealH,Image object)
        """
        pass

    def CachedThumbnailCustomAsync(self, w, h, asyncHandler):
        """(integer idealW,integer idealH,Image object) = CachedThumbnailCustomAsync(integer w,integer h,object asyncHandler)
        
        Args:
            w (int):
            h (int):
            asyncHandler (asyncHandler):

        Returns:
            (integer idealW,integer idealH,Image object)
        """
        pass

    def ChildGridPositionLookup(self, childPath):
        """(integer x,integer y) = ChildGridPositionLookup(string childPath)
        
        Args:
            childPath (str):

        Returns:
            (integer x,integer y)
        """
        pass

    def ChildGridPositionSet(self, childPath, x, y):
        """ChildGridPositionSet(string childPath,integer x,integer y)
        
        Args:
            childPath (str):
            x (int):
            y (int):

        Returns:
            None
        """
        pass

    def ChildManualOrderLookup(self, childPath):
        """integer pos = ChildManualOrderLookup(string childPath)
        
        Args:
            childPath (str):

        Returns:
            pos (int):
        """
        pass

    def ChildManualOrderSet(self, childPath, pos):
        """ChildManualOrderSet(string childPath,integer pos)
        
        Args:
            childPath (str):
            pos (int):

        Returns:
            None
        """
        pass

    def CommitSharedMarkup(self, sharedMarkup):
        """CommitSharedMarkup(object sharedMarkup)
        
        Args:
            sharedMarkup (sharedMarkup):

        Returns:
            None
        """
        pass

    def CommitUserMarkup(self, userMarkup):
        """CommitUserMarkup(object userMarkup)
        
        Args:
            userMarkup (userMarkup):

        Returns:
            None
        """
        pass

    def Desc(self):
        """string = Desc()
        
        Returns:
            str
        """
        pass

    def DirCount(self, listMode):
        """integer = DirCount(integer listMode)
        
        Args:
            listMode (int):

        Returns:
            int
        """
        pass

    def DirList(self, listMode, asCopy):
        """Array object = DirList(integer listMode,integer asCopy)
        
        Args:
            listMode (int):
            asCopy (int):

        Returns:
            object (Array):
        """
        pass

    def Extension(self):
        """string = Extension()
        
        Returns:
            str
        """
        pass

    def GridExtents(self):
        """(integer bottom,integer right) = GridExtents()
        
        Returns:
            (integer bottom,integer right)
        """
        pass

    def GridInsert(self, doRows, x, y, count):
        """GridInsert(integer doRows,integer x,integer y,integer count)
        
        Args:
            doRows (int):
            x (int):
            y (int):
            count (int):

        Returns:
            None
        """
        pass

    def GridIsEmpty(self, doRows, x, y):
        """boolean = GridIsEmpty(integer doRows,integer x,integer y)
        
        Args:
            doRows (int):
            x (int):
            y (int):

        Returns:
            bool
        """
        pass

    def GridIsEmptyCell(self, x, y):
        """(boolean,DirCacheEntry object) = GridIsEmptyCell(integer x,integer y)
        
        Args:
            x (int):
            y (int):

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

    def GridRemove(self, doRows, x, y, count, force):
        """GridRemove(integer doRows,integer x,integer y,integer count,integer force)
        
        Args:
            doRows (int):
            x (int):
            y (int):
            count (int):
            force (int):

        Returns:
            None
        """
        pass

    def GridSetExtents(self, bottom, right):
        """GridSetExtents(integer bottom,integer right)
        
        Args:
            bottom (int):
            right (int):

        Returns:
            None
        """
        pass

    def Label(self):
        """string = Label()
        
        Returns:
            str
        """
        pass

    def Metadata(self):
        """Attributes object = Metadata()
        
        Returns:
            object (Attributes):
        """
        pass

    def ModTime(self):
        """string = ModTime()
        
        Returns:
            str
        """
        pass

    def Name(self):
        """string = Name()
        
        Returns:
            str
        """
        pass

    def Parent(self):
        """DirCacheEntry object = Parent()
        
        Returns:
            object (DirCacheEntry):
        """
        pass

    def Path(self):
        """string = Path()
        
        Returns:
            str
        """
        pass

    def ReferenceSource(self):
        """DirCacheEntry object = ReferenceSource()
        
        Returns:
            object (DirCacheEntry):
        """
        pass

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

    def ReferencedList(self, asCopy):
        """Array object = ReferencedList(integer asCopy)
        
        Args:
            asCopy (int):

        Returns:
            object (Array):
        """
        pass

    def SharedMarkup(self, asWritable):
        """Unknown object = SharedMarkup(integer asWritable)
        
        Args:
            asWritable (int):

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

    def Size(self):
        """float size = Size()
        
        Returns:
            size (float):
        """
        pass

    def Thumbnail(self, w, h):
        """(integer idealW,integer idealH,Image object) = Thumbnail(integer w,integer h)
        
        Args:
            w (int):
            h (int):

        Returns:
            (integer idealW,integer idealH,Image object)
        """
        pass

    def ToolTip(self):
        """string = ToolTip()
        
        Returns:
            str
        """
        pass

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

    def UserMarkup(self, asWritable):
        """Unknown object = UserMarkup(integer asWritable)
        
        Args:
            asWritable (int):

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

    def Username(self):
        """string = Username()
        
        Returns:
            str
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirCacheFileMetrics:
    """DirCacheFileMetrics"""
    def __init__(self, unknown=None):
        pass

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

    def Markup(self):
        """Attributes object = Markup()
        
        Returns:
            object (Attributes):
        """
        pass

    def Metadata(self):
        """Attributes object = Metadata()
        
        Returns:
            object (Attributes):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirCacheGridPosDest:
    """DirCacheGridPosDest"""
    def __init__(self, unknown=None):
        pass

    def GridPos(self):
        """(DirCacheEntry object,integer x,integer y) = GridPos()
        
        Returns:
            (DirCacheEntry object,integer x,integer y)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirCacheManualOrderDest:
    """DirCacheManualOrderDest"""
    def __init__(self, unknown=None):
        pass

    def BetweenPaths(self, asPaths):
        """(DirCacheEntry object,string nameBefore,string nameAfter) = BetweenPaths(integer asPaths)
        
        Args:
            asPaths (int):

        Returns:
            (DirCacheEntry object,string nameBefore,string nameAfter)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirCacheSynthetic:
    """DirCacheSynthetic"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            object (DirCacheSyntheticEntry):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirCacheSyntheticEntry:
    """DirCacheSyntheticEntry"""
    def __init__(self, unknown=None):
        pass

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

    def DirByIndex(self, listMode, index):
        """DirCacheSyntheticEntry object = DirByIndex(integer listMode,integer index)
        
        Args:
            listMode (int):
            index (int):

        Returns:
            object (DirCacheSyntheticEntry):
        """
        pass

    def DirCount(self, listMode):
        """integer = DirCount(integer listMode)
        
        Args:
            listMode (int):

        Returns:
            int
        """
        pass

    def DirUsername(self):
        """string = DirUsername()
        
        Returns:
            str
        """
        pass

    def FileExtension(self):
        """string = FileExtension()
        
        Returns:
            str
        """
        pass

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

    def ModTime(self):
        """string = ModTime()
        
        Returns:
            str
        """
        pass

    def Name(self):
        """string = Name()
        
        Returns:
            str
        """
        pass

    def Path(self):
        """string = Path()
        
        Returns:
            str
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DirEntryThumbAsync:
    """DirEntryThumbAsync"""
    def __init__(self, unknown=None):
        pass

    def Failed(self, dirCacheEntry):
        """Failed(object dirCacheEntry)
        
        Args:
            dirCacheEntry (dirCacheEntry):

        Returns:
            None
        """
        pass

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

    def Ready(self, dirCacheEntry, idealW, idealH, image):
        """Ready(object dirCacheEntry,integer idealW,integer idealH,object image)
        
        Args:
            dirCacheEntry (dirCacheEntry):
            idealW (int):
            idealH (int):
            image (lx.object.Image):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DrawingOverride:
    """DrawingOverride"""
    def __init__(self, unknown=None):
        pass

    def AffectedItems(self, scene, collection):
        """AffectedItems(object scene,object collection)
        
        Args:
            scene (scene):
            collection (collection):

        Returns:
            None
        """
        pass

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

    def DrawVisitor(self, scene, view):
        """Unknown object = DrawVisitor(object scene,object view)
        
        Args:
            scene (scene):
            view (view):

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

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

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

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

        Returns:
            styles (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Drop:
    """Drop"""
    def __init__(self, unknown=None):
        pass

    def ActionList(self, source, dest, addDropAction):
        """ActionList(object source,object dest,object addDropAction)
        
        Args:
            source (lxu.object.Item):
            dest (dest):
            addDropAction (addDropAction):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def Preview(self, source, dest, action, draw):
        """Preview(object source,object dest,integer action,object draw)
        
        Args:
            source (lxu.object.Item):
            dest (dest):
            action (int):
            draw (draw):

        Returns:
            None
        """
        pass

    def Recognize(self, source):
        """Recognize(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class DropPreviewDefault:
    """DropPreviewDefault"""
    def __init__(self, unknown=None):
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Edge:
    """Edge"""
    def __init__(self, unknown=None):
        pass

    def ClearMapValue(self, map):
        """ClearMapValue(id map)
        
        Args:
            map (id):

        Returns:
            None
        """
        pass

    def Endpoints(self):
        """(id point0,id point1) = Endpoints()
        
        Returns:
            (id point0,id point1)
        """
        pass

    def Enumerate(self, mode, visitor, monitor):
        """Enumerate(integer mode,object visitor,object monitor)
        
        Args:
            mode (int):
            visitor (visitor):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def ID(self):
        """id = ID()
        
        Returns:
            id
        """
        pass

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

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

    def MapEvaluate(self, map, value):
        """boolean = MapEvaluate(id map,float[] value)
        
        Args:
            map (id):
            value (float[]):

        Returns:
            bool
        """
        pass

    def MapValue(self, map, value):
        """boolean = MapValue(id map,float[] value)
        
        Args:
            map (id):
            value (float[]):

        Returns:
            bool
        """
        pass

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

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

    def PolygonByIndex(self, index):
        """id polygonID = PolygonByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            polygonID (id):
        """
        pass

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

    def RepresentativePolygon(self):
        """(id polygonID,integer index) = RepresentativePolygon()
        
        Returns:
            (id polygonID,integer index)
        """
        pass

    def Select(self, edge):
        """Select(id edge)
        
        Args:
            edge (id):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SelectEndpoints(self, v0, v1):
        """SelectEndpoints(id v0,id v1)
        
        Args:
            v0 (id):
            v1 (id):

        Returns:
            None
        """
        pass

    def SetMapValue(self, map, value):
        """SetMapValue(id map,float[] value)
        
        Args:
            map (id):
            value (float[]):

        Returns:
            None
        """
        pass

    def SetMarks(self, set):
        """SetMarks(integer set)
        
        Args:
            set (int):

        Returns:
            None
        """
        pass

    def SharedPolygon(self, edgeID):
        """id polygonID = SharedPolygon(id edgeID)
        
        Args:
            edgeID (id):

        Returns:
            polygonID (id):
        """
        pass

    def Spawn(self):
        """Edge object = Spawn()
        
        Returns:
            object (Edge):
        """
        pass

    def Symmetry(self):
        """id edgeID = Symmetry()
        
        Returns:
            edgeID (id):
        """
        pass

    def TestMarks(self, mode):
        """boolean = TestMarks(integer mode)
        
        Args:
            mode (int):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class EdgePacketTranslation:
    """EdgePacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

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

    def Mesh(self, packet):
        """Mesh object = Mesh(pointer packet)
        
        Args:
            packet (int):

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

    def Packet(self, vertexA, vertexB, polygon, mesh):
        """pointer = Packet(id vertexA,id vertexB,id polygon,object mesh)
        
        Args:
            vertexA (id):
            vertexB (id):
            polygon (id):
            mesh (lxu.object.Mesh):

        Returns:
            int
        """
        pass

    def Polygon(self, packet):
        """id polygon = Polygon(pointer packet)
        
        Args:
            packet (int):

        Returns:
            polygon (id):
        """
        pass

    def Vertices(self, packet):
        """(id vertexA,id vertexB) = Vertices(pointer packet)
        
        Args:
            packet (int):

        Returns:
            (id vertexA,id vertexB)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ElementAxisPacket:
    """ElementAxisPacket"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ElementCenterPacket:
    """ElementCenterPacket"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Envelope:
    """Envelope"""
    def __init__(self, unknown=None):
        pass

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

    def EndBehavior(self, side):
        """integer = EndBehavior(integer side)
        
        Args:
            side (int):

        Returns:
            int
        """
        pass

    def Enumerator(self):
        """Keyframe object = Enumerator()
        
        Returns:
            object (Keyframe):
        """
        pass

    def EvaluateF(self, time):
        """float value = EvaluateF(float time)
        
        Args:
            time (float):

        Returns:
            value (float):
        """
        pass

    def EvaluateI(self, time):
        """integer value = EvaluateI(float time)
        
        Args:
            time (float):

        Returns:
            value (int):
        """
        pass

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

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

    def SetEndBehavior(self, behavior, side):
        """SetEndBehavior(integer behavior,integer side)
        
        Args:
            behavior (int):
            side (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class EvalModifier:
    """EvalModifier"""
    def __init__(self, unknown=None):
        pass

    def Alloc(self, item, index, eval):
        """Unknown object = Alloc(object item,integer index,object eval)
        
        Args:
            item (lxu.object.Item):
            index (int):
            eval (eval):

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

    def Next(self):
        """(object,integer index) = Next()
        
        Returns:
            index) ((object,integer):
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Evaluation:
    """Evaluation"""
    def __init__(self, unknown=None):
        pass

    def AddChannel(self, item, index, type):
        """integer attr = AddChannel(object item,integer index,integer type)
        
        Args:
            item (lxu.object.Item):
            index (int):
            type (int):

        Returns:
            attr (int):
        """
        pass

    def AddChannelName(self, item, name, type):
        """integer attr = AddChannelName(object item,string name,integer type)
        
        Args:
            item (lxu.object.Item):
            name (str):
            type (int):

        Returns:
            attr (int):
        """
        pass

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

    def GetBakedSample(self, index, bracket):
        """(float fraction,Unknown object) = GetBakedSample(integer index,integer bracket)
        
        Args:
            index (int):
            bracket (int):

        Returns:
            (float fraction,Unknown object)
        """
        pass

    def GetCache(self):
        """pointer = GetCache()
        
        Returns:
            int
        """
        pass

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

    def ReadTime(self):
        """integer attr = ReadTime()
        
        Returns:
            attr (int):
        """
        pass

    def SetAlternate(self):
        """ChannelWrite object = SetAlternate()
        
        Returns:
            object (ChannelWrite):
        """
        pass

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

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

        Returns:
            None
        """
        pass

    def SetCache(self, cache):
        """SetCache(pointer cache)
        
        Args:
            cache (int):

        Returns:
            None
        """
        pass

    def SimulationRange(self):
        """(float start,float end) = SimulationRange()
        
        Returns:
            (float start,float end)
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class EvaluationStack:
    """EvaluationStack"""
    def __init__(self, unknown=None):
        pass

    def AddFilter(self, filter):
        """AddFilter(object filter)
        
        Args:
            filter (filter):

        Returns:
            None
        """
        pass

    def Branch(self):
        """EvaluationStack object = Branch()
        
        Returns:
            object (EvaluationStack):
        """
        pass

    def Type(self):
        """string = Type()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class EventGuide:
    """EventGuide"""
    def __init__(self, unknown=None):
        pass

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

    def Limits(self, inner, outer):
        """integer = Limits(float inner,float outer)
        
        Args:
            inner (float):
            outer (float):

        Returns:
            int
        """
        pass

    def Proximity(self, toolVector, element):
        """(integer,vector pos,float dist,integer priority) = Proximity(object toolVector,pointer element)
        
        Args:
            toolVector (toolVector):
            element (int):

        Returns:
            (integer,vector pos,float dist,integer priority)
        """
        pass

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

        Returns:
            int
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class EventTranslatePacket:
    """EventTranslatePacket"""
    def __init__(self, unknown=None):
        pass

    def AddGuide(self, guide, client):
        """AddGuide(object guide,pointer client)
        
        Args:
            guide (guide):
            client (int):

        Returns:
            None
        """
        pass

    def GetConstraint(self, toolVector):
        """(integer,vector center,vector vector) = GetConstraint(object toolVector)
        
        Args:
            toolVector (toolVector):

        Returns:
            (integer,vector center,vector vector)
        """
        pass

    def GetNewPosition(self, toolVector):
        """vector pos = GetNewPosition(object toolVector)
        
        Args:
            toolVector (toolVector):

        Returns:
            pos (tuple):
        """
        pass

    def HitHandle(self, toolVector, handle):
        """HitHandle(object toolVector,vector handle)
        
        Args:
            toolVector (toolVector):
            handle (tuple):

        Returns:
            None
        """
        pass

    def ModelDelta(self, toolVector, handle):
        """vector delta = ModelDelta(object toolVector,vector handle)
        
        Args:
            toolVector (toolVector):
            handle (tuple):

        Returns:
            delta (tuple):
        """
        pass

    def ModelLineDelta(self, toolVector, center, dir, handle):
        """vector delta = ModelLineDelta(object toolVector,vector center,vector dir,vector handle)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            dir (tuple):
            handle (tuple):

        Returns:
            delta (tuple):
        """
        pass

    def ModelPlaneDelta(self, toolVector, center, normal, handle):
        """vector delta = ModelPlaneDelta(object toolVector,vector center,vector normal,vector handle)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            normal (tuple):
            handle (tuple):

        Returns:
            delta (tuple):
        """
        pass

    def RemoveGuide(self, guide, client):
        """integer = RemoveGuide(object guide,pointer client)
        
        Args:
            guide (guide):
            client (int):

        Returns:
            int
        """
        pass

    def ScreenToRay(self, toolVector, x, y):
        """(vector pos,vector dir) = ScreenToRay(object toolVector,float x,float y)
        
        Args:
            toolVector (toolVector):
            x (float):
            y (float):

        Returns:
            (vector pos,vector dir)
        """
        pass

    def SetLinearConstraint(self, toolVector, center, dir):
        """SetLinearConstraint(object toolVector,vector center,vector dir)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            dir (tuple):

        Returns:
            None
        """
        pass

    def SetLinearSnapConstraint(self, toolVector, center, dir):
        """SetLinearSnapConstraint(object toolVector,vector center,vector dir)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            dir (tuple):

        Returns:
            None
        """
        pass

    def SetPlanarConstraint(self, toolVector, center, normal):
        """SetPlanarConstraint(object toolVector,vector center,vector normal)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            normal (tuple):

        Returns:
            None
        """
        pass

    def SetPlanarSnapConstraint(self, toolVector, center, dir):
        """SetPlanarSnapConstraint(object toolVector,vector center,vector dir)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            dir (tuple):

        Returns:
            None
        """
        pass

    def SetSnapRange(self, inner, outer):
        """SetSnapRange(float inner,float outer)
        
        Args:
            inner (float):
            outer (float):

        Returns:
            None
        """
        pass

    def SnapPosition(self, toolVector, pos):
        """(integer,vector snapPos) = SnapPosition(object toolVector,vector pos)
        
        Args:
            toolVector (toolVector):
            pos (tuple):

        Returns:
            snapPos) ((integer,vector):
        """
        pass

    def ToModel(self, toolVector):
        """(integer,vector pos,vector axis) = ToModel(object toolVector)
        
        Args:
            toolVector (toolVector):

        Returns:
            (integer,vector pos,vector axis)
        """
        pass

    def ToModelLine(self, toolVector, center, dir):
        """vector pos = ToModelLine(object toolVector,vector center,vector dir)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            dir (tuple):

        Returns:
            pos (tuple):
        """
        pass

    def ToModelPlane(self, toolVector, center, normal):
        """vector pos = ToModelPlane(object toolVector,vector center,vector normal)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            normal (tuple):

        Returns:
            pos (tuple):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ExternalRender:
    """ExternalRender"""
    def __init__(self, unknown=None):
        pass

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

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

    def SetBufferQueue(self, bufferQueue):
        """SetBufferQueue(object bufferQueue)
        
        Args:
            bufferQueue (bufferQueue):

        Returns:
            None
        """
        pass

    def SetNotifier(self, notifier):
        """SetNotifier(object notifier)
        
        Args:
            notifier (lx.object.Notifier):

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ExternalRenderBufferQueue:
    """ExternalRenderBufferQueue"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ExternalRenderNotifier:
    """ExternalRenderNotifier"""
    def __init__(self, unknown=None):
        pass

    def SetStatusText(self, text):
        """SetStatusText(string text)
        
        Args:
            text (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Factory:
    """Factory"""
    def __init__(self, unknown=None):
        pass

    def InfoTag(self, type):
        """string value = InfoTag(string type)
        
        Args:
            type (str):

        Returns:
            value (str):
        """
        pass

    def Module(self):
        """string module = Module()
        
        Returns:
            module (str):
        """
        pass

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

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

    def TagByIndex(self, index):
        """(string type,string value) = TagByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (string type,string value)
        """
        pass

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

    def UserName(self):
        """string userName = UserName()
        
        Returns:
            userName (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Falloff:
    """Falloff"""
    def __init__(self, unknown=None):
        pass

    def Bounds(self):
        """bounds box = Bounds()
        
        Returns:
            box (bounds):
        """
        pass

    def SetMesh(self, mesh):
        """matrix xfrm = SetMesh(object mesh)
        
        Args:
            mesh (lxu.object.Mesh):

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

    def WeightF(self, position, point, polygon):
        """float = WeightF(vector position,id point,id polygon)
        
        Args:
            position (tuple):
            point (id):
            polygon (id):

        Returns:
            float
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FalloffPacket:
    """FalloffPacket"""
    def __init__(self, unknown=None):
        pass

    def Screen(self, vts, x, y):
        """float = Screen(object vts,integer x,integer y)
        
        Args:
            vts (vts):
            x (int):
            y (int):

        Returns:
            float
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FileRedirect:
    """FileRedirect"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

    def Locate(self, path, type):
        """string = Locate(string path,string type)
        
        Args:
            path (str):
            type (str):

        Returns:
            str
        """
        pass

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

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

    def NeutralFormat(self, allow):
        """NeutralFormat(integer allow)
        
        Args:
            allow (int):

        Returns:
            None
        """
        pass

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

        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FileReference:
    """FileReference"""
    def __init__(self, unknown=None):
        pass

    def Mode(self):
        """integer mode = Mode()
        
        Returns:
            mode (int):
        """
        pass

    def NiceName(self):
        """string = NiceName()
        
        Returns:
            str
        """
        pass

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

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

        Returns:
            object (FileReference):
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FileSysDest:
    """FileSysDest"""
    def __init__(self, unknown=None):
        pass

    def AsDir(self):
        """string dir = AsDir()
        
        Returns:
            dir (str):
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Force:
    """Force"""
    def __init__(self, unknown=None):
        pass

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

    def Force(self, pos):
        """vector force = Force(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            force (tuple):
        """
        pass

    def ForceM(self, pos, mass):
        """vector force = ForceM(vector pos,float mass)
        
        Args:
            pos (tuple):
            mass (float):

        Returns:
            force (tuple):
        """
        pass

    def ForceV(self, pos, velocity):
        """vector force = ForceV(vector pos,vector velocity)
        
        Args:
            pos (tuple):
            velocity (tuple):

        Returns:
            force (tuple):
        """
        pass

    def ForceVM(self, pos, velocity, mass):
        """vector force = ForceVM(vector pos,vector velocity,float mass)
        
        Args:
            pos (tuple):
            velocity (tuple):
            mass (float):

        Returns:
            force (tuple):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FormDeleteEntryDest:
    """FormDeleteEntryDest"""
    def __init__(self, unknown=None):
        pass

    def Delete(self, hash):
        """Delete(string hash)
        
        Args:
            hash (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FormEntryDest:
    """FormEntryDest"""
    def __init__(self, unknown=None):
        pass

    def ControlHash(self):
        """string hash = ControlHash()
        
        Returns:
            hash (str):
        """
        pass

    def FormHash(self):
        """string hash = FormHash()
        
        Returns:
            hash (str):
        """
        pass

    def Position(self):
        """integer pos = Position()
        
        Returns:
            pos (int):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FormEntryDropPreview:
    """FormEntryDropPreview"""
    def __init__(self, unknown=None):
        pass

    def MarkControl(self, hash, syntheticIndex, pos):
        """MarkControl(string hash,integer syntheticIndex,integer pos)
        
        Args:
            hash (str):
            syntheticIndex (int):
            pos (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class FrameBuffer:
    """FrameBuffer"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            index (int):
        """
        pass

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

        Returns:
            object
        """
        pass

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

        Returns:
            int
        """
        pass

    def AreaProcessingActive(self, bufferIndex):
        """integer active = AreaProcessingActive(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            active (int):
        """
        pass

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

        Returns:
            int
        """
        pass

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

        Returns:
            object
        """
        pass

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

    def CreateFrameBufferTargetImage(self, type, w, h):
        """Unknown object = CreateFrameBufferTargetImage(integer type,integer w,integer h)
        
        Args:
            type (int):
            w (int):
            h (int):

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

    def GetBloomEnabled(self, bufferIndex):
        """integer = GetBloomEnabled(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            int
        """
        pass

    def GetBloomRadius(self, bufferIndex):
        """float = GetBloomRadius(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetBloomThreshold(self, bufferIndex):
        """float = GetBloomThreshold(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetColorization(self, bufferIndex):
        """float = GetColorization(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetExpType(self, bufferIndex):
        """integer = GetExpType(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            int
        """
        pass

    def GetHueOffset(self, bufferIndex):
        """float = GetHueOffset(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetISO(self, bufferIndex):
        """float = GetISO(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputBlackLevel(self, bufferIndex):
        """float = GetInputBlackLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputBlueGrayLevel(self, bufferIndex):
        """float = GetInputBlueGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputGrayLevel(self, bufferIndex):
        """float = GetInputGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputGreenGrayLevel(self, bufferIndex):
        """float = GetInputGreenGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputMaxBlueLevel(self, bufferIndex):
        """float = GetInputMaxBlueLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputMaxGreenLevel(self, bufferIndex):
        """float = GetInputMaxGreenLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputMaxRedLevel(self, bufferIndex):
        """float = GetInputMaxRedLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputMinBlueLevel(self, bufferIndex):
        """float = GetInputMinBlueLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputMinGreenLevel(self, bufferIndex):
        """float = GetInputMinGreenLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputMinRedLevel(self, bufferIndex):
        """float = GetInputMinRedLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputRedGrayLevel(self, bufferIndex):
        """float = GetInputRedGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInputWhiteLevel(self, bufferIndex):
        """float = GetInputWhiteLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInvInputBlueGrayLevel(self, bufferIndex):
        """float = GetInvInputBlueGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInvInputGrayLevel(self, bufferIndex):
        """float = GetInvInputGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInvInputGreenGrayLevel(self, bufferIndex):
        """float = GetInvInputGreenGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetInvInputRedGrayLevel(self, bufferIndex):
        """float = GetInvInputRedGrayLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputBlackLevel(self, bufferIndex):
        """float = GetOutputBlackLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputColorspace(self):
        """string = GetOutputColorspace()
        
        Returns:
            str
        """
        pass

    def GetOutputGamma(self, bufferIndex):
        """float = GetOutputGamma(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputInvGamma(self, bufferIndex):
        """float = GetOutputInvGamma(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputMaxBlueLevel(self, bufferIndex):
        """float = GetOutputMaxBlueLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputMaxGreenLevel(self, bufferIndex):
        """float = GetOutputMaxGreenLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputMaxRedLevel(self, bufferIndex):
        """float = GetOutputMaxRedLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputMinBlueLevel(self, bufferIndex):
        """float = GetOutputMinBlueLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputMinGreenLevel(self, bufferIndex):
        """float = GetOutputMinGreenLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputMinRedLevel(self, bufferIndex):
        """float = GetOutputMinRedLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetOutputWhiteLevel(self, bufferIndex):
        """float = GetOutputWhiteLevel(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetRenderPassName(self, name):
        """GetRenderPassName(byte[] name)
        
        Args:
            name (byte[]):

        Returns:
            None
        """
        pass

    def GetSaturation(self, bufferIndex):
        """float = GetSaturation(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetSaveProcessed(self, bufferIndex):
        """integer = GetSaveProcessed(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            int
        """
        pass

    def GetStereoComposite(self):
        """integer composite = GetStereoComposite()
        
        Returns:
            composite (int):
        """
        pass

    def GetStereoEyeDisplay(self):
        """integer eyeDisplay = GetStereoEyeDisplay()
        
        Returns:
            eyeDisplay (int):
        """
        pass

    def GetTargetColor(self, bufferIndex):
        """float color = GetTargetColor(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            color (float):
        """
        pass

    def GetToneAmt(self, bufferIndex):
        """float = GetToneAmt(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def GetToneMap(self, bufferIndex):
        """integer = GetToneMap(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            int
        """
        pass

    def GetVignetteAmount(self, bufferIndex):
        """float = GetVignetteAmount(integer bufferIndex)
        
        Args:
            bufferIndex (int):

        Returns:
            float
        """
        pass

    def IsStereo(self):
        """integer isStereo = IsStereo()
        
        Returns:
            isStereo (int):
        """
        pass

    def Lookup(self, name, item):
        """object = Lookup(string name,object item)
        
        Args:
            name (str):
            item (lxu.object.Item):

        Returns:
            object
        """
        pass

    def LookupByIdentity(self, identity):
        """object = LookupByIdentity(string identity)
        
        Args:
            identity (str):

        Returns:
            object
        """
        pass

    def SetBloomEnabled(self, bufferIndex, enabled):
        """SetBloomEnabled(integer bufferIndex,integer enabled)
        
        Args:
            bufferIndex (int):
            enabled (int):

        Returns:
            None
        """
        pass

    def SetBloomRadius(self, bufferIndex, radius):
        """SetBloomRadius(integer bufferIndex,float radius)
        
        Args:
            bufferIndex (int):
            radius (float):

        Returns:
            None
        """
        pass

    def SetBloomThreshold(self, bufferIndex, threshold):
        """SetBloomThreshold(integer bufferIndex,float threshold)
        
        Args:
            bufferIndex (int):
            threshold (float):

        Returns:
            None
        """
        pass

    def SetColorization(self, bufferIndex, colorization):
        """SetColorization(integer bufferIndex,float colorization)
        
        Args:
            bufferIndex (int):
            colorization (float):

        Returns:
            None
        """
        pass

    def SetExpType(self, bufferIndex, expType):
        """SetExpType(integer bufferIndex,integer expType)
        
        Args:
            bufferIndex (int):
            expType (int):

        Returns:
            None
        """
        pass

    def SetEyeSide(self, eyeSide):
        """SetEyeSide(integer eyeSide)
        
        Args:
            eyeSide (int):

        Returns:
            None
        """
        pass

    def SetHueOffset(self, bufferIndex, hueOffset):
        """SetHueOffset(integer bufferIndex,float hueOffset)
        
        Args:
            bufferIndex (int):
            hueOffset (float):

        Returns:
            None
        """
        pass

    def SetISO(self, bufferIndex, iso):
        """SetISO(integer bufferIndex,float iso)
        
        Args:
            bufferIndex (int):
            iso (float):

        Returns:
            None
        """
        pass

    def SetInputBlackLevel(self, bufferIndex, blackLevel):
        """SetInputBlackLevel(integer bufferIndex,float blackLevel)
        
        Args:
            bufferIndex (int):
            blackLevel (float):

        Returns:
            None
        """
        pass

    def SetInputBlueGrayLevel(self, bufferIndex, gamma):
        """SetInputBlueGrayLevel(integer bufferIndex,float gamma)
        
        Args:
            bufferIndex (int):
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputGrayLevel(self, bufferIndex, gamma):
        """SetInputGrayLevel(integer bufferIndex,float gamma)
        
        Args:
            bufferIndex (int):
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputGreenGrayLevel(self, bufferIndex, gamma):
        """SetInputGreenGrayLevel(integer bufferIndex,float gamma)
        
        Args:
            bufferIndex (int):
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputMaxBlueLevel(self, bufferIndex, level):
        """SetInputMaxBlueLevel(integer bufferIndex,float level)
        
        Args:
            bufferIndex (int):
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMaxGreenLevel(self, bufferIndex, level):
        """SetInputMaxGreenLevel(integer bufferIndex,float level)
        
        Args:
            bufferIndex (int):
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMaxRedLevel(self, bufferIndex, level):
        """SetInputMaxRedLevel(integer bufferIndex,float level)
        
        Args:
            bufferIndex (int):
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMinBlueLevel(self, bufferIndex, level):
        """SetInputMinBlueLevel(integer bufferIndex,float level)
        
        Args:
            bufferIndex (int):
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMinGreenLevel(self, bufferIndex, level):
        """SetInputMinGreenLevel(integer bufferIndex,float level)
        
        Args:
            bufferIndex (int):
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMinRedLevel(self, bufferIndex, level):
        """SetInputMinRedLevel(integer bufferIndex,float level)
        
        Args:
            bufferIndex (int):
            level (float):

        Returns:
            None
        """
        pass

    def SetInputRedGrayLevel(self, bufferIndex, gamma):
        """SetInputRedGrayLevel(integer bufferIndex,float gamma)
        
        Args:
            bufferIndex (int):
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputWhiteLevel(self, bufferIndex, whiteLevel):
        """SetInputWhiteLevel(integer bufferIndex,float whiteLevel)
        
        Args:
            bufferIndex (int):
            whiteLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputBlackLevel(self, bufferIndex, blackLevel):
        """SetOutputBlackLevel(integer bufferIndex,float blackLevel)
        
        Args:
            bufferIndex (int):
            blackLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputColormapping(self, colormapping):
        """SetOutputColormapping(object colormapping)
        
        Args:
            colormapping (colormapping):

        Returns:
            None
        """
        pass

    def SetOutputColorspace(self, colorspace):
        """SetOutputColorspace(string colorspace)
        
        Args:
            colorspace (str):

        Returns:
            None
        """
        pass

    def SetOutputGamma(self, bufferIndex, gamma):
        """SetOutputGamma(integer bufferIndex,float gamma)
        
        Args:
            bufferIndex (int):
            gamma (float):

        Returns:
            None
        """
        pass

    def SetOutputMaxBlueLevel(self, bufferIndex, whiteLevel):
        """SetOutputMaxBlueLevel(integer bufferIndex,float whiteLevel)
        
        Args:
            bufferIndex (int):
            whiteLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMaxGreenLevel(self, bufferIndex, whiteLevel):
        """SetOutputMaxGreenLevel(integer bufferIndex,float whiteLevel)
        
        Args:
            bufferIndex (int):
            whiteLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMaxRedLevel(self, bufferIndex, whiteLevel):
        """SetOutputMaxRedLevel(integer bufferIndex,float whiteLevel)
        
        Args:
            bufferIndex (int):
            whiteLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMinBlueLevel(self, bufferIndex, blackLevel):
        """SetOutputMinBlueLevel(integer bufferIndex,float blackLevel)
        
        Args:
            bufferIndex (int):
            blackLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMinGreenLevel(self, bufferIndex, blackLevel):
        """SetOutputMinGreenLevel(integer bufferIndex,float blackLevel)
        
        Args:
            bufferIndex (int):
            blackLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMinRedLevel(self, bufferIndex, blackLevel):
        """SetOutputMinRedLevel(integer bufferIndex,float blackLevel)
        
        Args:
            bufferIndex (int):
            blackLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputWhiteLevel(self, bufferIndex, whiteLevel):
        """SetOutputWhiteLevel(integer bufferIndex,float whiteLevel)
        
        Args:
            bufferIndex (int):
            whiteLevel (float):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetSaturation(self, bufferIndex, saturation):
        """SetSaturation(integer bufferIndex,float saturation)
        
        Args:
            bufferIndex (int):
            saturation (float):

        Returns:
            None
        """
        pass

    def SetSaveProcessed(self, bufferIndex, enabled):
        """SetSaveProcessed(integer bufferIndex,integer enabled)
        
        Args:
            bufferIndex (int):
            enabled (int):

        Returns:
            None
        """
        pass

    def SetStereoComposite(self, composite):
        """SetStereoComposite(integer composite)
        
        Args:
            composite (int):

        Returns:
            None
        """
        pass

    def SetStereoEyeDisplay(self, eyeDisplay):
        """SetStereoEyeDisplay(integer eyeDisplay)
        
        Args:
            eyeDisplay (int):

        Returns:
            None
        """
        pass

    def SetTargetColor(self, bufferIndex, color):
        """SetTargetColor(integer bufferIndex,double[] color)
        
        Args:
            bufferIndex (int):
            color (double[]):

        Returns:
            None
        """
        pass

    def SetToneAmt(self, bufferIndex, toneAmt):
        """SetToneAmt(integer bufferIndex,float toneAmt)
        
        Args:
            bufferIndex (int):
            toneAmt (float):

        Returns:
            None
        """
        pass

    def SetToneMap(self, bufferIndex, toneMap):
        """SetToneMap(integer bufferIndex,integer toneMap)
        
        Args:
            bufferIndex (int):
            toneMap (int):

        Returns:
            None
        """
        pass

    def SetVignetteAmount(self, bufferIndex, radius):
        """SetVignetteAmount(integer bufferIndex,float radius)
        
        Args:
            bufferIndex (int):
            radius (float):

        Returns:
            None
        """
        pass

    def Size(self, index):
        """(integer width,integer height) = Size(integer index)
        
        Args:
            index (int):

        Returns:
            (integer width,integer height)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GLImage:
    """GLImage"""
    def __init__(self, unknown=None):
        pass

    def SetImage(self, image):
        """SetImage(object image)
        
        Args:
            image (lx.object.Image):

        Returns:
            None
        """
        pass

    def Size(self):
        """(float w,float h) = Size()
        
        Returns:
            (float w,float h)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GLMaterial:
    """GLMaterial"""
    def __init__(self, unknown=None):
        pass

    def Alpha(self):
        """float alpha = Alpha()
        
        Returns:
            alpha (float):
        """
        pass

    def Color(self):
        """vector color = Color()
        
        Returns:
            color (tuple):
        """
        pass

    def DiffuseAmount(self):
        """float amount = DiffuseAmount()
        
        Returns:
            amount (float):
        """
        pass

    def DiffuseColor(self):
        """vector color = DiffuseColor()
        
        Returns:
            color (tuple):
        """
        pass

    def Glossiness(self):
        """float amount = Glossiness()
        
        Returns:
            amount (float):
        """
        pass

    def LuminosityColor(self):
        """vector color = LuminosityColor()
        
        Returns:
            color (tuple):
        """
        pass

    def ReflectionColor(self):
        """vector color = ReflectionColor()
        
        Returns:
            color (tuple):
        """
        pass

    def SpecularAmount(self):
        """float amount = SpecularAmount()
        
        Returns:
            amount (float):
        """
        pass

    def SpecularColor(self):
        """vector color = SpecularColor()
        
        Returns:
            color (tuple):
        """
        pass

    def TwoSide(self):
        """integer value = TwoSide()
        
        Returns:
            value (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GLShadingListener:
    """GLShadingListener"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GLViewport:
    """GLViewport"""
    def __init__(self, unknown=None):
        pass

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

    def DropDestination(self, x, y):
        """Unknown object = DropDestination(integer x,integer y)
        
        Args:
            x (int):
            y (int):

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

    def Initialize(self, client):
        """Initialize(object client)
        
        Args:
            client (client):

        Returns:
            None
        """
        pass

    def MouseEvent(self, event):
        """MouseEvent(integer event)
        
        Args:
            event (int):

        Returns:
            None
        """
        pass

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

    def SetSize(self, w, h):
        """SetSize(integer w,integer h)
        
        Args:
            w (int):
            h (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GLViewportClient:
    """GLViewportClient"""
    def __init__(self, unknown=None):
        pass

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

    def MouseButton(self):
        """integer button = MouseButton()
        
        Returns:
            button (int):
        """
        pass

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

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

    def TabletPressure(self):
        """float press = TabletPressure()
        
        Returns:
            press (float):
        """
        pass

    def TabletTilt(self):
        """float tilt = TabletTilt()
        
        Returns:
            tilt (float):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GeoCacheSegment:
    """GeoCacheSegment"""
    def __init__(self, unknown=None):
        pass

    def GetBBox(self):
        """bounds bbox = GetBBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def GetPolygonVertexFeature(self, feature, featureData, count, start):
        """GetPolygonVertexFeature(integer feature,pointer featureData,integer count,integer start)
        
        Args:
            feature (int):
            featureData (int):
            count (int):
            start (int):

        Returns:
            None
        """
        pass

    def GetPolygonVertexInds(self, count, start):
        """integer polyVertexInds = GetPolygonVertexInds(integer count,integer start)
        
        Args:
            count (int):
            start (int):

        Returns:
            polyVertexInds (int):
        """
        pass

    def GetVertexFeature(self, feature, featureData, count, start):
        """GetVertexFeature(integer feature,pointer featureData,integer count,integer start)
        
        Args:
            feature (int):
            featureData (int):
            count (int):
            start (int):

        Returns:
            None
        """
        pass

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

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

    def VertexFeatureCount(self, feature):
        """integer count = VertexFeatureCount(integer feature)
        
        Args:
            feature (int):

        Returns:
            count (int):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GeoCacheSurface:
    """GeoCacheSurface"""
    def __init__(self, unknown=None):
        pass

    def GetBBox(self):
        """bounds bbox = GetBBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def GetXfrm(self, endpoint):
        """(vector pos,matrix rot,vector scl) = GetXfrm(integer endpoint)
        
        Args:
            endpoint (int):

        Returns:
            (vector pos,matrix rot,vector scl)
        """
        pass

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

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

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

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

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

    def MaterialPTag(self):
        """string = MaterialPTag()
        
        Returns:
            str
        """
        pass

    def PartPTag(self):
        """string = PartPTag()
        
        Returns:
            str
        """
        pass

    def PickPTag(self):
        """string = PickPTag()
        
        Returns:
            str
        """
        pass

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

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

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

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

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

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

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GradientFilter:
    """GradientFilter"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self, time, value):
        """float = Evaluate(float time,float value)
        
        Args:
            time (float):
            value (float):

        Returns:
            float
        """
        pass

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

        Returns:
            float
        """
        pass

    def MultiSample(self, time, other):
        """float = MultiSample(float time,object other)
        
        Args:
            time (float):
            other (other):

        Returns:
            float
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GroupDeformer:
    """GroupDeformer"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def PointEffect(self, meshIndex, point, deformer, weight, max):
        """integer count = PointEffect(integer meshIndex,id point,unsigned[] deformer,float[] weight,integer max)
        
        Args:
            meshIndex (int):
            point (id):
            deformer (unsigned[]):
            weight (float[]):
            max (int):

        Returns:
            count (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GroupDest:
    """GroupDest"""
    def __init__(self, unknown=None):
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GroupEnumerator:
    """GroupEnumerator"""
    def __init__(self, unknown=None):
        pass

    def Channel(self):
        """(Item object,integer index) = Channel()
        
        Returns:
            (Item object,integer index)
        """
        pass

    def Enumerate(self, visitor, mask):
        """Enumerate(object visitor,integer mask)
        
        Args:
            visitor (visitor):
            mask (int):

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GroupItem:
    """GroupItem"""
    def __init__(self, unknown=None):
        pass

    def Enumerator(self):
        """GroupEnumerator object = Enumerator()
        
        Returns:
            object (GroupEnumerator):
        """
        pass

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

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GroupMemberChanDest:
    """GroupMemberChanDest"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class GroupMemberItemDest:
    """GroupMemberItemDest"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class HandleDraw:
    """HandleDraw"""
    def __init__(self, unknown=None):
        pass

    def AxisHandle(self, pos, mat, axis, part, len, flags):
        """AxisHandle(vector pos,matrix mat,integer axis,integer part,float len,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            axis (int):
            part (int):
            len (float):
            flags (int):

        Returns:
            None
        """
        pass

    def CrossHandle(self, pos, mat, part, flags):
        """CrossHandle(vector pos,matrix mat,integer part,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Handle(self, pos, mat, part, flags):
        """Handle(vector pos,matrix mat,integer part,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def LineHandleHilight(self, pos, dir, part, flags):
        """LineHandleHilight(vector pos,vector dir,integer part,integer flags)
        
        Args:
            pos (tuple):
            dir (tuple):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def MoveHandle(self, pos, mat, axis, part, flags):
        """MoveHandle(vector pos,matrix mat,integer axis,integer part,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            axis (int):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def PlaneHandle(self, pos, mat, axis, part, flags):
        """PlaneHandle(vector pos,matrix mat,integer axis,integer part,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            axis (int):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def PlaneHandleHilight(self, pos, norm, part, flags):
        """PlaneHandleHilight(vector pos,vector norm,integer part,integer flags)
        
        Args:
            pos (tuple):
            norm (tuple):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def PointHandle(self, pos, part, flags):
        """PointHandle(vector pos,integer part,integer flags)
        
        Args:
            pos (tuple):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def RotateHandle(self, pos, mat, axis, part, sAngle, eAngle, facing, flags):
        """RotateHandle(vector pos,matrix mat,integer axis,integer part,float sAngle,float eAngle,integer facing,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            axis (int):
            part (int):
            sAngle (float):
            eAngle (float):
            facing (int):
            flags (int):

        Returns:
            None
        """
        pass

    def RotateMouseHandle(self, center, pos, mat, axis, part, flags):
        """RotateMouseHandle(vector center,vector pos,matrix mat,integer axis,integer part,integer flags)
        
        Args:
            center (tuple):
            pos (tuple):
            mat (lx.object.Matrix):
            axis (int):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def ScaleHandle(self, pos, mat, axis, part, offset, line, flags):
        """ScaleHandle(vector pos,matrix mat,integer axis,integer part,float offset,integer line,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            axis (int):
            part (int):
            offset (float):
            line (int):
            flags (int):

        Returns:
            None
        """
        pass

    def XHandle(self, pos, mat, part, flags):
        """XHandle(vector pos,matrix mat,integer part,integer flags)
        
        Args:
            pos (tuple):
            mat (lx.object.Matrix):
            part (int):
            flags (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Image:
    """Image"""
    def __init__(self, unknown=None):
        pass

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

    def GetLine(self, y, type, buf):
        """data[] = GetLine(integer y,integer type,data[] buf)
        
        Args:
            y (int):
            type (int):
            buf (data[]):

        Returns:
            data[]
        """
        pass

    def GetPixel(self, x, y, type, pixel):
        """GetPixel(integer x,integer y,integer type,data[] pixel)
        
        Args:
            x (int):
            y (int):
            type (int):
            pixel (data[]):

        Returns:
            None
        """
        pass

    def Size(self):
        """(integer w,integer h) = Size()
        
        Returns:
            (integer w,integer h)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageFilter:
    """ImageFilter"""
    def __init__(self, unknown=None):
        pass

    def Generate(self, width, height, monitor):
        """Image object = Generate(integer width,integer height,object monitor)
        
        Args:
            width (int):
            height (int):
            monitor (monitor):

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

    def MultiSample(self, monitor, image):
        """Image object = MultiSample(object monitor,object image)
        
        Args:
            monitor (monitor):
            image (lx.object.Image):

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

    def SingleSample(self, src):
        """vector dest = SingleSample(vector src)
        
        Args:
            src (tuple):

        Returns:
            dest (tuple):
        """
        pass

    def SingleSampleN(self, src, num):
        """float dest = SingleSampleN(float[] src,integer num)
        
        Args:
            src (float[]):
            num (int):

        Returns:
            dest (float):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageFilterMetrics:
    """ImageFilterMetrics"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageLevelSample:
    """ImageLevelSample"""
    def __init__(self, unknown=None):
        pass

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

    def GetLevelSize(self, level):
        """(integer width,integer height) = GetLevelSize(integer level)
        
        Args:
            level (int):

        Returns:
            (integer width,integer height)
        """
        pass

    def GetLine(self, level, y, buf):
        """float[] = GetLine(integer level,integer y,float[] buf)
        
        Args:
            level (int):
            y (int):
            buf (float[]):

        Returns:
            float[]
        """
        pass

    def GetPixel(self, level, x, y, type, pixel):
        """GetPixel(integer level,integer x,integer y,integer type,data[] pixel)
        
        Args:
            level (int):
            x (int):
            y (int):
            type (int):
            pixel (data[]):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageLoaderTarget:
    """ImageLoaderTarget"""
    def __init__(self, unknown=None):
        pass

    def SetColorspace(self, colorspace):
        """SetColorspace(string colorspace)
        
        Args:
            colorspace (str):

        Returns:
            None
        """
        pass

    def SetColorspaceDepth(self, depth):
        """SetColorspaceDepth(integer depth)
        
        Args:
            depth (int):

        Returns:
            None
        """
        pass

    def SetMap(self, ncolor):
        """SetMap(integer ncolor)
        
        Args:
            ncolor (int):

        Returns:
            None
        """
        pass

    def SetSize(self, type, width, height):
        """SetSize(integer type,integer width,integer height)
        
        Args:
            type (int):
            width (int):
            height (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageMonitor:
    """ImageMonitor"""
    def __init__(self, unknown=None):
        pass

    def AspectRange(self):
        """(float minAspect,float maxAspect,float idealAspect) = AspectRange()
        
        Returns:
            (float minAspect,float maxAspect,float idealAspect)
        """
        pass

    def Draw(self, imageForDrawing):
        """Draw(object imageForDrawing)
        
        Args:
            imageForDrawing (imageForDrawing):

        Returns:
            None
        """
        pass

    def Image(self, imageToAnalyze, frameBufferToAnalyze, bufferIndex, x1, y1, x2, y2, imageProcessingRead, processedThumbnail):
        """Image(object imageToAnalyze,object frameBufferToAnalyze,integer bufferIndex,float x1,float y1,float x2,float y2,object imageProcessingRead,object processedThumbnail)
        
        Args:
            imageToAnalyze (imageToAnalyze):
            frameBufferToAnalyze (frameBufferToAnalyze):
            bufferIndex (int):
            x1 (float):
            y1 (float):
            x2 (float):
            y2 (float):
            imageProcessingRead (imageProcessingRead):
            processedThumbnail (processedThumbnail):

        Returns:
            None
        """
        pass

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

    def ImageSource(self, source):
        """ImageSource(string source)
        
        Args:
            source (str):

        Returns:
            None
        """
        pass

    def MouseDown(self, startx, starty, w, h):
        """MouseDown(integer startx,integer starty,integer w,integer h)
        
        Args:
            startx (int):
            starty (int):
            w (int):
            h (int):

        Returns:
            None
        """
        pass

    def MouseMove(self, startx, starty, cx, cy, w, h):
        """MouseMove(integer startx,integer starty,integer cx,integer cy,integer w,integer h)
        
        Args:
            startx (int):
            starty (int):
            cx (int):
            cy (int):
            w (int):
            h (int):

        Returns:
            None
        """
        pass

    def MouseTrack(self, cx, cy, w, h):
        """MouseTrack(integer cx,integer cy,integer w,integer h)
        
        Args:
            cx (int):
            cy (int):
            w (int):
            h (int):

        Returns:
            None
        """
        pass

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

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

    def MouseUp(self, startx, starty, cx, cy, w, h):
        """MouseUp(integer startx,integer starty,integer cx,integer cy,integer w,integer h)
        
        Args:
            startx (int):
            starty (int):
            cx (int):
            cy (int):
            w (int):
            h (int):

        Returns:
            None
        """
        pass

    def ToolTip(self, cx, cy, w, h):
        """string = ToolTip(integer cx,integer cy,integer w,integer h)
        
        Args:
            cx (int):
            cy (int):
            w (int):
            h (int):

        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageProcessing:
    """ImageProcessing"""
    def __init__(self, unknown=None):
        pass

    def ApplyToFrameBuffer(self, frameBuffer, bufferIndex):
        """ApplyToFrameBuffer(object frameBuffer,integer bufferIndex)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):

        Returns:
            None
        """
        pass

    def ApplyToFrameBufferOverride(self, frameBuffer, bufferIndex, opOverride):
        """ApplyToFrameBufferOverride(object frameBuffer,integer bufferIndex,integer opOverride)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):
            opOverride (int):

        Returns:
            None
        """
        pass

    def ApplyToImage(self, srcImage, dstImage):
        """ApplyToImage(object srcImage,object dstImage)
        
        Args:
            srcImage (srcImage):
            dstImage (dstImage):

        Returns:
            None
        """
        pass

    def ApplyToImageFromFrameBuffer(self, frameBuffer, bufferIndex, image, xOffset, yOffset, zoom):
        """ApplyToImageFromFrameBuffer(object frameBuffer,integer bufferIndex,object image,float xOffset,float yOffset,float zoom)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):
            image (lx.object.Image):
            xOffset (float):
            yOffset (float):
            zoom (float):

        Returns:
            None
        """
        pass

    def ApplyToImageFromFrameBufferOverride(self, frameBuffer, bufferIndex, image, xOffset, yOffset, zoom, opOverride):
        """ApplyToImageFromFrameBufferOverride(object frameBuffer,integer bufferIndex,object image,float xOffset,float yOffset,float zoom,integer opOverride)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):
            image (lx.object.Image):
            xOffset (float):
            yOffset (float):
            zoom (float):
            opOverride (int):

        Returns:
            None
        """
        pass

    def ApplyToImageOverride(self, srcImage, dstImage, opOverride):
        """ApplyToImageOverride(object srcImage,object dstImage,integer opOverride)
        
        Args:
            srcImage (srcImage):
            dstImage (dstImage):
            opOverride (int):

        Returns:
            None
        """
        pass

    def AreaProcessingActive(self):
        """integer active = AreaProcessingActive()
        
        Returns:
            active (int):
        """
        pass

    def CopySettingsFromFrameBuffer(self, frameBuffer, bufferIndex):
        """CopySettingsFromFrameBuffer(object frameBuffer,integer bufferIndex)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):

        Returns:
            None
        """
        pass

    def CopySettingsToFrameBuffer(self, frameBuffer, bufferIndex):
        """CopySettingsToFrameBuffer(object frameBuffer,integer bufferIndex)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):

        Returns:
            None
        """
        pass

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

    def GetBloomEnabled(self):
        """integer enabled = GetBloomEnabled()
        
        Returns:
            enabled (int):
        """
        pass

    def GetBloomRadius(self):
        """float radius = GetBloomRadius()
        
        Returns:
            radius (float):
        """
        pass

    def GetBloomThreshold(self):
        """float threshold = GetBloomThreshold()
        
        Returns:
            threshold (float):
        """
        pass

    def GetColorSpaceEmbedding(self):
        """integer colorSpaceEmbedding = GetColorSpaceEmbedding()
        
        Returns:
            colorSpaceEmbedding (int):
        """
        pass

    def GetColorization(self):
        """float colorization = GetColorization()
        
        Returns:
            colorization (float):
        """
        pass

    def GetExpType(self):
        """integer expType = GetExpType()
        
        Returns:
            expType (int):
        """
        pass

    def GetHueOffset(self):
        """float hueOffset = GetHueOffset()
        
        Returns:
            hueOffset (float):
        """
        pass

    def GetISO(self):
        """float iso = GetISO()
        
        Returns:
            iso (float):
        """
        pass

    def GetIdentifier(self):
        """string string = GetIdentifier()
        
        Returns:
            string (str):
        """
        pass

    def GetImageProcessingOperators(self):
        """integer ops = GetImageProcessingOperators()
        
        Returns:
            ops (int):
        """
        pass

    def GetInputBlackLevel(self):
        """float inputBlackLevel = GetInputBlackLevel()
        
        Returns:
            inputBlackLevel (float):
        """
        pass

    def GetInputBlueGrayLevel(self):
        """float gamma = GetInputBlueGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputGrayLevel(self):
        """float gamma = GetInputGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputGreenGrayLevel(self):
        """float gamma = GetInputGreenGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputMaxBlueLevel(self):
        """float inputLevel = GetInputMaxBlueLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMaxGreenLevel(self):
        """float inputLevel = GetInputMaxGreenLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMaxRedLevel(self):
        """float inputLevel = GetInputMaxRedLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMinBlueLevel(self):
        """float inputLevel = GetInputMinBlueLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMinGreenLevel(self):
        """float inputLevel = GetInputMinGreenLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMinRedLevel(self):
        """float inputLevel = GetInputMinRedLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputRedGrayLevel(self):
        """float gamma = GetInputRedGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputWhiteLevel(self):
        """float inputWhiteLevel = GetInputWhiteLevel()
        
        Returns:
            inputWhiteLevel (float):
        """
        pass

    def GetInvInputBlueGrayLevel(self):
        """float invGamma = GetInvInputBlueGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetInvInputGrayLevel(self):
        """float invGamma = GetInvInputGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetInvInputGreenGrayLevel(self):
        """float invGamma = GetInvInputGreenGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetInvInputRedGrayLevel(self):
        """float invGamma = GetInvInputRedGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetOutputBlackLevel(self):
        """float outputBlackLevel = GetOutputBlackLevel()
        
        Returns:
            outputBlackLevel (float):
        """
        pass

    def GetOutputColorspace(self):
        """string = GetOutputColorspace()
        
        Returns:
            str
        """
        pass

    def GetOutputGamma(self):
        """float outputGamma = GetOutputGamma()
        
        Returns:
            outputGamma (float):
        """
        pass

    def GetOutputInvGamma(self):
        """float outputInvGamma = GetOutputInvGamma()
        
        Returns:
            outputInvGamma (float):
        """
        pass

    def GetOutputMaxBlueLevel(self):
        """float outputLevel = GetOutputMaxBlueLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMaxGreenLevel(self):
        """float outputLevel = GetOutputMaxGreenLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMaxRedLevel(self):
        """float outputLevel = GetOutputMaxRedLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMinBlueLevel(self):
        """float outputLevel = GetOutputMinBlueLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMinGreenLevel(self):
        """float outputLevel = GetOutputMinGreenLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMinRedLevel(self):
        """float outputLevel = GetOutputMinRedLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputWhiteLevel(self):
        """float outputWhiteLevel = GetOutputWhiteLevel()
        
        Returns:
            outputWhiteLevel (float):
        """
        pass

    def GetSaturation(self):
        """float saturation = GetSaturation()
        
        Returns:
            saturation (float):
        """
        pass

    def GetSaveProcessed(self):
        """integer enabled = GetSaveProcessed()
        
        Returns:
            enabled (int):
        """
        pass

    def GetSourceImageGamma(self):
        """float gamma = GetSourceImageGamma()
        
        Returns:
            gamma (float):
        """
        pass

    def GetSourceImageIsStereoSideBySide(self):
        """integer isStereo = GetSourceImageIsStereoSideBySide()
        
        Returns:
            isStereo (int):
        """
        pass

    def GetStereoComposite(self):
        """integer mode = GetStereoComposite()
        
        Returns:
            mode (int):
        """
        pass

    def GetStereoEye(self):
        """integer eye = GetStereoEye()
        
        Returns:
            eye (int):
        """
        pass

    def GetTargetColor(self):
        """float color = GetTargetColor()
        
        Returns:
            color (float):
        """
        pass

    def GetToneAmt(self):
        """float toneAmt = GetToneAmt()
        
        Returns:
            toneAmt (float):
        """
        pass

    def GetToneMap(self):
        """integer toneMap = GetToneMap()
        
        Returns:
            toneMap (int):
        """
        pass

    def GetVignetteAmount(self):
        """float amount = GetVignetteAmount()
        
        Returns:
            amount (float):
        """
        pass

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

    def SetBloomEnabled(self, enabled):
        """SetBloomEnabled(integer enabled)
        
        Args:
            enabled (int):

        Returns:
            None
        """
        pass

    def SetBloomRadius(self, radius):
        """SetBloomRadius(float radius)
        
        Args:
            radius (float):

        Returns:
            None
        """
        pass

    def SetBloomThreshold(self, threshold):
        """SetBloomThreshold(float threshold)
        
        Args:
            threshold (float):

        Returns:
            None
        """
        pass

    def SetColorization(self, colorization):
        """SetColorization(float colorization)
        
        Args:
            colorization (float):

        Returns:
            None
        """
        pass

    def SetExpType(self, expType):
        """SetExpType(integer expType)
        
        Args:
            expType (int):

        Returns:
            None
        """
        pass

    def SetHueOffset(self, hueOffset):
        """SetHueOffset(float hueOffset)
        
        Args:
            hueOffset (float):

        Returns:
            None
        """
        pass

    def SetISO(self, iso):
        """SetISO(float iso)
        
        Args:
            iso (float):

        Returns:
            None
        """
        pass

    def SetIdentifier(self, string):
        """SetIdentifier(string string)
        
        Args:
            string (str):

        Returns:
            None
        """
        pass

    def SetImageProcessingOperators(self, ops):
        """SetImageProcessingOperators(integer ops)
        
        Args:
            ops (int):

        Returns:
            None
        """
        pass

    def SetInputBlackLevel(self, blackLevel):
        """SetInputBlackLevel(float blackLevel)
        
        Args:
            blackLevel (float):

        Returns:
            None
        """
        pass

    def SetInputBlueGrayLevel(self, gamma):
        """SetInputBlueGrayLevel(float gamma)
        
        Args:
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputGrayLevel(self, gamma):
        """SetInputGrayLevel(float gamma)
        
        Args:
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputGreenGrayLevel(self, gamma):
        """SetInputGreenGrayLevel(float gamma)
        
        Args:
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputMaxBlueLevel(self, level):
        """SetInputMaxBlueLevel(float level)
        
        Args:
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMaxGreenLevel(self, level):
        """SetInputMaxGreenLevel(float level)
        
        Args:
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMaxRedLevel(self, level):
        """SetInputMaxRedLevel(float level)
        
        Args:
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMinBlueLevel(self, level):
        """SetInputMinBlueLevel(float level)
        
        Args:
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMinGreenLevel(self, level):
        """SetInputMinGreenLevel(float level)
        
        Args:
            level (float):

        Returns:
            None
        """
        pass

    def SetInputMinRedLevel(self, level):
        """SetInputMinRedLevel(float level)
        
        Args:
            level (float):

        Returns:
            None
        """
        pass

    def SetInputRedGrayLevel(self, gamma):
        """SetInputRedGrayLevel(float gamma)
        
        Args:
            gamma (float):

        Returns:
            None
        """
        pass

    def SetInputWhiteLevel(self, whiteLevel):
        """SetInputWhiteLevel(float whiteLevel)
        
        Args:
            whiteLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputBlackLevel(self, blackLevel):
        """SetOutputBlackLevel(float blackLevel)
        
        Args:
            blackLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputColormapping(self, colormapping):
        """SetOutputColormapping(object colormapping)
        
        Args:
            colormapping (colormapping):

        Returns:
            None
        """
        pass

    def SetOutputColorspace(self, colorspace):
        """SetOutputColorspace(string colorspace)
        
        Args:
            colorspace (str):

        Returns:
            None
        """
        pass

    def SetOutputGamma(self, gamma):
        """SetOutputGamma(float gamma)
        
        Args:
            gamma (float):

        Returns:
            None
        """
        pass

    def SetOutputMaxBlueLevel(self, outputLevel):
        """SetOutputMaxBlueLevel(float outputLevel)
        
        Args:
            outputLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMaxGreenLevel(self, outputLevel):
        """SetOutputMaxGreenLevel(float outputLevel)
        
        Args:
            outputLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMaxRedLevel(self, outputLevel):
        """SetOutputMaxRedLevel(float outputLevel)
        
        Args:
            outputLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMinBlueLevel(self, outputLevel):
        """SetOutputMinBlueLevel(float outputLevel)
        
        Args:
            outputLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMinGreenLevel(self, outputLevel):
        """SetOutputMinGreenLevel(float outputLevel)
        
        Args:
            outputLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputMinRedLevel(self, outputLevel):
        """SetOutputMinRedLevel(float outputLevel)
        
        Args:
            outputLevel (float):

        Returns:
            None
        """
        pass

    def SetOutputWhiteLevel(self, whiteLevel):
        """SetOutputWhiteLevel(float whiteLevel)
        
        Args:
            whiteLevel (float):

        Returns:
            None
        """
        pass

    def SetSaturation(self, saturation):
        """SetSaturation(float saturation)
        
        Args:
            saturation (float):

        Returns:
            None
        """
        pass

    def SetSaveProcessed(self, enabled):
        """SetSaveProcessed(integer enabled)
        
        Args:
            enabled (int):

        Returns:
            None
        """
        pass

    def SetSourceImageGamma(self, gamma):
        """SetSourceImageGamma(float gamma)
        
        Args:
            gamma (float):

        Returns:
            None
        """
        pass

    def SetSourceImageIsStereoSideBySide(self, isStereo):
        """SetSourceImageIsStereoSideBySide(integer isStereo)
        
        Args:
            isStereo (int):

        Returns:
            None
        """
        pass

    def SetStereoComposite(self, mode):
        """SetStereoComposite(integer mode)
        
        Args:
            mode (int):

        Returns:
            None
        """
        pass

    def SetStereoEye(self, eye):
        """SetStereoEye(integer eye)
        
        Args:
            eye (int):

        Returns:
            None
        """
        pass

    def SetTargetColor(self, color):
        """SetTargetColor(double[] color)
        
        Args:
            color (double[]):

        Returns:
            None
        """
        pass

    def SetToneAmt(self, toneAmt):
        """SetToneAmt(float toneAmt)
        
        Args:
            toneAmt (float):

        Returns:
            None
        """
        pass

    def SetToneMap(self, toneMap):
        """SetToneMap(integer toneMap)
        
        Args:
            toneMap (int):

        Returns:
            None
        """
        pass

    def SetVignetteAmount(self, amount):
        """SetVignetteAmount(float amount)
        
        Args:
            amount (float):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageProcessingListener:
    """ImageProcessingListener"""
    def __init__(self, unknown=None):
        pass

    def Changed(self, identifier, eventCode):
        """Changed(string identifier,integer eventCode)
        
        Args:
            identifier (str):
            eventCode (int):

        Returns:
            None
        """
        pass

    def Reset(self, identifier):
        """Reset(string identifier)
        
        Args:
            identifier (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageProcessingRead:
    """ImageProcessingRead"""
    def __init__(self, unknown=None):
        pass

    def ApplyToFrameBuffer(self, frameBuffer, bufferIndex):
        """ApplyToFrameBuffer(object frameBuffer,integer bufferIndex)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):

        Returns:
            None
        """
        pass

    def ApplyToFrameBufferOverride(self, frameBuffer, bufferIndex, opOverride):
        """ApplyToFrameBufferOverride(object frameBuffer,integer bufferIndex,integer opOverride)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):
            opOverride (int):

        Returns:
            None
        """
        pass

    def ApplyToImage(self, srcImage, dstImage):
        """ApplyToImage(object srcImage,object dstImage)
        
        Args:
            srcImage (srcImage):
            dstImage (dstImage):

        Returns:
            None
        """
        pass

    def ApplyToImageFromFrameBuffer(self, frameBuffer, bufferIndex, image, xOffset, yOffset, zoom):
        """ApplyToImageFromFrameBuffer(object frameBuffer,integer bufferIndex,object image,float xOffset,float yOffset,float zoom)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):
            image (lx.object.Image):
            xOffset (float):
            yOffset (float):
            zoom (float):

        Returns:
            None
        """
        pass

    def ApplyToImageFromFrameBufferOverride(self, frameBuffer, bufferIndex, image, xOffset, yOffset, zoom, opOverride):
        """ApplyToImageFromFrameBufferOverride(object frameBuffer,integer bufferIndex,object image,float xOffset,float yOffset,float zoom,integer opOverride)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):
            image (lx.object.Image):
            xOffset (float):
            yOffset (float):
            zoom (float):
            opOverride (int):

        Returns:
            None
        """
        pass

    def ApplyToImageOverride(self, srcImage, dstImage, opOverride):
        """ApplyToImageOverride(object srcImage,object dstImage,integer opOverride)
        
        Args:
            srcImage (srcImage):
            dstImage (dstImage):
            opOverride (int):

        Returns:
            None
        """
        pass

    def AreaProcessingActive(self):
        """integer active = AreaProcessingActive()
        
        Returns:
            active (int):
        """
        pass

    def CopySettingsToFrameBuffer(self, frameBuffer, bufferIndex):
        """CopySettingsToFrameBuffer(object frameBuffer,integer bufferIndex)
        
        Args:
            frameBuffer (frameBuffer):
            bufferIndex (int):

        Returns:
            None
        """
        pass

    def GetBloomEnabled(self):
        """integer enabled = GetBloomEnabled()
        
        Returns:
            enabled (int):
        """
        pass

    def GetBloomRadius(self):
        """float radius = GetBloomRadius()
        
        Returns:
            radius (float):
        """
        pass

    def GetBloomThreshold(self):
        """float threshold = GetBloomThreshold()
        
        Returns:
            threshold (float):
        """
        pass

    def GetColorization(self):
        """float colorization = GetColorization()
        
        Returns:
            colorization (float):
        """
        pass

    def GetExpType(self):
        """integer expType = GetExpType()
        
        Returns:
            expType (int):
        """
        pass

    def GetHueOffset(self):
        """float hueOffset = GetHueOffset()
        
        Returns:
            hueOffset (float):
        """
        pass

    def GetISO(self):
        """float iso = GetISO()
        
        Returns:
            iso (float):
        """
        pass

    def GetIdentifier(self):
        """string string = GetIdentifier()
        
        Returns:
            string (str):
        """
        pass

    def GetImageProcessingOperators(self):
        """integer ops = GetImageProcessingOperators()
        
        Returns:
            ops (int):
        """
        pass

    def GetInputBlackLevel(self):
        """float inputLevel = GetInputBlackLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputBlueGrayLevel(self):
        """float gamma = GetInputBlueGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputGrayLevel(self):
        """float gamma = GetInputGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputGreenGrayLevel(self):
        """float gamma = GetInputGreenGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputMaxBlueLevel(self):
        """float inputLevel = GetInputMaxBlueLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMaxGreenLevel(self):
        """float inputLevel = GetInputMaxGreenLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMaxRedLevel(self):
        """float inputLevel = GetInputMaxRedLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMinBlueLevel(self):
        """float inputLevel = GetInputMinBlueLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMinGreenLevel(self):
        """float inputLevel = GetInputMinGreenLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputMinRedLevel(self):
        """float inputLevel = GetInputMinRedLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInputRedGrayLevel(self):
        """float gamma = GetInputRedGrayLevel()
        
        Returns:
            gamma (float):
        """
        pass

    def GetInputWhiteLevel(self):
        """float inputLevel = GetInputWhiteLevel()
        
        Returns:
            inputLevel (float):
        """
        pass

    def GetInvInputBlueGrayLevel(self):
        """float invGamma = GetInvInputBlueGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetInvInputGrayLevel(self):
        """float invGamma = GetInvInputGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetInvInputGreenGrayLevel(self):
        """float invGamma = GetInvInputGreenGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetInvInputRedGrayLevel(self):
        """float invGamma = GetInvInputRedGrayLevel()
        
        Returns:
            invGamma (float):
        """
        pass

    def GetOutputBlackLevel(self):
        """float outputLevel = GetOutputBlackLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputColorspace(self):
        """string = GetOutputColorspace()
        
        Returns:
            str
        """
        pass

    def GetOutputGamma(self):
        """float outputGamma = GetOutputGamma()
        
        Returns:
            outputGamma (float):
        """
        pass

    def GetOutputInvGamma(self):
        """float outputInvGamma = GetOutputInvGamma()
        
        Returns:
            outputInvGamma (float):
        """
        pass

    def GetOutputMaxBlueLevel(self):
        """float outputLevel = GetOutputMaxBlueLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMaxGreenLevel(self):
        """float outputLevel = GetOutputMaxGreenLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMaxRedLevel(self):
        """float outputLevel = GetOutputMaxRedLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMinBlueLevel(self):
        """float outputLevel = GetOutputMinBlueLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMinGreenLevel(self):
        """float outputLevel = GetOutputMinGreenLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputMinRedLevel(self):
        """float outputLevel = GetOutputMinRedLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetOutputWhiteLevel(self):
        """float outputLevel = GetOutputWhiteLevel()
        
        Returns:
            outputLevel (float):
        """
        pass

    def GetSaturation(self):
        """float saturation = GetSaturation()
        
        Returns:
            saturation (float):
        """
        pass

    def GetSaveProcessed(self):
        """integer enabled = GetSaveProcessed()
        
        Returns:
            enabled (int):
        """
        pass

    def GetSourceImageGamma(self):
        """float gamma = GetSourceImageGamma()
        
        Returns:
            gamma (float):
        """
        pass

    def GetSourceImageIsStereoSideBySide(self):
        """integer isStereo = GetSourceImageIsStereoSideBySide()
        
        Returns:
            isStereo (int):
        """
        pass

    def GetStereoComposite(self):
        """integer mode = GetStereoComposite()
        
        Returns:
            mode (int):
        """
        pass

    def GetStereoEye(self):
        """integer eye = GetStereoEye()
        
        Returns:
            eye (int):
        """
        pass

    def GetTargetColor(self):
        """float color = GetTargetColor()
        
        Returns:
            color (float):
        """
        pass

    def GetToneAmt(self):
        """float toneAmt = GetToneAmt()
        
        Returns:
            toneAmt (float):
        """
        pass

    def GetToneMap(self):
        """integer toneMap = GetToneMap()
        
        Returns:
            toneMap (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageSegment:
    """ImageSegment"""
    def __init__(self, unknown=None):
        pass

    def GetSegment(self, y, left, right, rgba):
        """GetSegment(integer y,integer left,integer right,float[] rgba)
        
        Args:
            y (int):
            left (int):
            right (int):
            rgba (float[]):

        Returns:
            None
        """
        pass

    def SetSegment(self, y, left, right, type, line):
        """SetSegment(integer y,integer left,integer right,integer type,data[] line)
        
        Args:
            y (int):
            left (int):
            right (int):
            type (int):
            line (data[]):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ImageWrite:
    """ImageWrite"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            index (int):
        """
        pass

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

    def SetLine(self, y, type, line):
        """SetLine(integer y,integer type,data[] line)
        
        Args:
            y (int):
            type (int):
            line (data[]):

        Returns:
            None
        """
        pass

    def SetPixel(self, x, y, type, pixel):
        """SetPixel(integer x,integer y,integer type,data[] pixel)
        
        Args:
            x (int):
            y (int):
            type (int):
            pixel (data[]):

        Returns:
            None
        """
        pass

    def Size(self):
        """(integer w,integer h) = Size()
        
        Returns:
            (integer w,integer h)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class IndexImage:
    """IndexImage"""
    def __init__(self, unknown=None):
        pass

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

    def GetIndex(self, x, y):
        """integer index = GetIndex(integer x,integer y)
        
        Args:
            x (int):
            y (int):

        Returns:
            index (int):
        """
        pass

    def GetMap(self, index, type, pixel):
        """GetMap(integer index,integer type,data[] pixel)
        
        Args:
            index (int):
            type (int):
            pixel (data[]):

        Returns:
            None
        """
        pass

    def MapSize(self):
        """integer numColors = MapSize()
        
        Returns:
            numColors (int):
        """
        pass

    def Size(self):
        """(integer w,integer h) = Size()
        
        Returns:
            (integer w,integer h)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class IndexImageWrite:
    """IndexImageWrite"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            index (int):
        """
        pass

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

    def SetIndex(self, x, y, index):
        """SetIndex(integer x,integer y,integer index)
        
        Args:
            x (int):
            y (int):
            index (int):

        Returns:
            None
        """
        pass

    def SetMap(self, index, type, pixel):
        """SetMap(integer index,integer type,data[] pixel)
        
        Args:
            index (int):
            type (int):
            pixel (data[]):

        Returns:
            None
        """
        pass

    def Size(self):
        """(integer w,integer h) = Size()
        
        Returns:
            (integer w,integer h)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class InputDeviceInstance:
    """InputDeviceInstance"""
    def __init__(self, unknown=None):
        pass

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

    def AnalogMetrics(self, index):
        """(integer isAbsolute,integer isDirectional) = AnalogMetrics(integer index)
        
        Args:
            index (int):

        Returns:
            (integer isAbsolute,integer isDirectional)
        """
        pass

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

        Returns:
            str
        """
        pass

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

        Returns:
            str
        """
        pass

    def AnalogValue(self, index):
        """float value = AnalogValue(integer index)
        
        Args:
            index (int):

        Returns:
            value (float):
        """
        pass

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

    def ButtonIsDown(self, index):
        """boolean = ButtonIsDown(integer index)
        
        Args:
            index (int):

        Returns:
            bool
        """
        pass

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

        Returns:
            str
        """
        pass

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

        Returns:
            str
        """
        pass

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

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class InputDevices:
    """InputDevices"""
    def __init__(self, unknown=None):
        pass

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

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

        Returns:
            object (InputDeviceInstance):
        """
        pass

    def DeviceNameByIndex(self, index, name):
        """DeviceNameByIndex(integer index,string name)
        
        Args:
            index (int):
            name (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class InstanceAssets:
    """InstanceAssets"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            str
        """
        pass

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

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

        Returns:
            str
        """
        pass

    def IdentByIndex(self, index):
        """(integer isSeq,string fileType,string) = IdentByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (integer isSeq,string fileType,string)
        """
        pass

    def SetPath(self, ident, newPath):
        """SetPath(string ident,string newPath)
        
        Args:
            ident (str):
            newPath (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Instanceable:
    """Instanceable"""
    def __init__(self, unknown=None):
        pass

    def AddElements(self, tableau, instT0, instT1):
        """AddElements(object tableau,object instT0,object instT1)
        
        Args:
            tableau (tableau):
            instT0 (instT0):
            instT1 (instT1):

        Returns:
            None
        """
        pass

    def Compare(self, other):
        """integer = Compare(object other)
        
        Args:
            other (other):

        Returns:
            int
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class IntRange:
    """IntRange"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def First(self):
        """integer first = First()
        
        Returns:
            first (int):
        """
        pass

    def Last(self):
        """integer last = Last()
        
        Returns:
            last (int):
        """
        pass

    def Max(self):
        """integer max = Max()
        
        Returns:
            max (int):
        """
        pass

    def Min(self):
        """integer min = Min()
        
        Returns:
            min (int):
        """
        pass

    def Next(self):
        """integer i = Next()
        
        Returns:
            i (int):
        """
        pass

    def Prev(self):
        """integer i = Prev()
        
        Returns:
            i (int):
        """
        pass

    def Test(self, i):
        """boolean = Test(integer i)
        
        Args:
            i (int):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Interviewer:
    """Interviewer"""
    def __init__(self, unknown=None):
        pass

    def ButtonCommand(self):
        """string = ButtonCommand()
        
        Returns:
            str
        """
        pass

    def ButtonLabel(self):
        """string = ButtonLabel()
        
        Returns:
            str
        """
        pass

    def Description(self):
        """string = Description()
        
        Returns:
            str
        """
        pass

    def Title(self):
        """string = Title()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Item:
    """Item"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

        Returns:
            type (str):
        """
        pass

    def ChannelGradient(self, index):
        """(string input,string output) = ChannelGradient(integer index)
        
        Args:
            index (int):

        Returns:
            (string input,string output)
        """
        pass

    def ChannelIntHint(self, index):
        """hints hints = ChannelIntHint(integer index)
        
        Args:
            index (int):

        Returns:
            hints (hints):
        """
        pass

    def ChannelIsDriven(self, index):
        """boolean = ChannelIsDriven(integer index)
        
        Args:
            index (int):

        Returns:
            bool
        """
        pass

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

        Returns:
            index (int):
        """
        pass

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

        Returns:
            name (str):
        """
        pass

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

        Returns:
            package (str):
        """
        pass

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

        Returns:
            type (str):
        """
        pass

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

        Returns:
            type (int):
        """
        pass

    def ChannelVectorMode(self, index):
        """(integer mode,integer components) = ChannelVectorMode(integer index)
        
        Args:
            index (int):

        Returns:
            (integer mode,integer components)
        """
        pass

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

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

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

        Returns:
            str
        """
        pass

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

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

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

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

    def PackageAdd(self, package):
        """PackageAdd(string package)
        
        Args:
            package (str):

        Returns:
            None
        """
        pass

    def PackageRemove(self, package):
        """PackageRemove(string package)
        
        Args:
            package (str):

        Returns:
            None
        """
        pass

    def PackageStartIndex(self, package):
        """integer index = PackageStartIndex(string package)
        
        Args:
            package (str):

        Returns:
            index (int):
        """
        pass

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

        Returns:
            bool
        """
        pass

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

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

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

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetParent(self, parent):
        """SetParent(object parent)
        
        Args:
            parent (parent):

        Returns:
            None
        """
        pass

    def SetParentAndPosition(self, parent, pos):
        """SetParentAndPosition(object parent,integer pos)
        
        Args:
            parent (parent):
            pos (int):

        Returns:
            None
        """
        pass

    def SetSource(self, source):
        """SetSource(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            None
        """
        pass

    def SetTag(self, type, tag):
        """SetTag(integer type,string tag)
        
        Args:
            type (int):
            tag (str):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

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

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

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

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

        Returns:
            bool
        """
        pass

    def TestTypes(self, types):
        """boolean = TestTypes(int[] types)
        
        Args:
            types (int[]):

        Returns:
            bool
        """
        pass

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

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

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

    def WasLoaded(self, test):
        """boolean = WasLoaded(integer test)
        
        Args:
            test (int):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemChannel:
    """ItemChannel"""
    def __init__(self, unknown=None):
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemCollection:
    """ItemCollection"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

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

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

        Returns:
            count (int):
        """
        pass

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

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemGraph:
    """ItemGraph"""
    def __init__(self, unknown=None):
        pass

    def AddLink(self, from_obj, to_obj):
        """AddLink(object from_obj,object to_obj)
        
        Args:
            from_obj (from_obj):
            to_obj (to_obj):

        Returns:
            None
        """
        pass

    def DeleteLink(self, from_obj, to_obj):
        """DeleteLink(object from_obj,object to_obj)
        
        Args:
            from_obj (from_obj):
            to_obj (to_obj):

        Returns:
            None
        """
        pass

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

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

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

        Returns:
            count (int):
        """
        pass

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

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

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

        Returns:
            count (int):
        """
        pass

    def SetLink(self, from_obj, fromIndex, to_obj, toIndex):
        """SetLink(object from_obj,integer fromIndex,object to_obj,integer toIndex)
        
        Args:
            from_obj (from_obj):
            fromIndex (int):
            to_obj (to_obj):
            toIndex (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemInfluence:
    """ItemInfluence"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            flags (int):
        """
        pass

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

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemListType:
    """ItemListType"""
    def __init__(self, unknown=None):
        pass

    def GenerateList(self, scene, collection):
        """GenerateList(object scene,object collection)
        
        Args:
            scene (scene):
            collection (collection):

        Returns:
            None
        """
        pass

    def SetArgument(self, arg):
        """SetArgument(string arg)
        
        Args:
            arg (str):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemPacketTranslation:
    """ItemPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

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

    def Packet(self, item):
        """pointer = Packet(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemReplacement:
    """ItemReplacement"""
    def __init__(self, unknown=None):
        pass

    def NotifierByIndex(self, itemType, channelName, index):
        """string = NotifierByIndex(string itemType,string channelName,integer index)
        
        Args:
            itemType (str):
            channelName (str):
            index (int):

        Returns:
            str
        """
        pass

    def NotifierCount(self, itemType, channelName):
        """integer count = NotifierCount(string itemType,string channelName)
        
        Args:
            itemType (str):
            channelName (str):

        Returns:
            count (int):
        """
        pass

    def ReplaceItems(self, current, replacement, targetType):
        """ReplaceItems(object current,object replacement,integer targetType)
        
        Args:
            current (current):
            replacement (replacement):
            targetType (int):

        Returns:
            None
        """
        pass

    def Types(self, curType):
        """string repTypes = Types(string curType)
        
        Args:
            curType (str):

        Returns:
            repTypes (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ItemTypeDest:
    """ItemTypeDest"""
    def __init__(self, unknown=None):
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Keyframe:
    """Keyframe"""
    def __init__(self, unknown=None):
        pass

    def AddF(self, time, value):
        """AddF(float time,float value)
        
        Args:
            time (float):
            value (float):

        Returns:
            None
        """
        pass

    def AddI(self, time, value):
        """AddI(float time,integer value)
        
        Args:
            time (float):
            value (int):

        Returns:
            None
        """
        pass

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

    def Find(self, time, side):
        """Find(float time,integer side)
        
        Args:
            time (float):
            side (int):

        Returns:
            None
        """
        pass

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

    def GetBroken(self):
        """(integer breaks,integer side) = GetBroken()
        
        Returns:
            (integer breaks,integer side)
        """
        pass

    def GetSlope(self, side):
        """float slope = GetSlope(integer side)
        
        Args:
            side (int):

        Returns:
            slope (float):
        """
        pass

    def GetSlopeType(self, side):
        """(integer type,integer weighted) = GetSlopeType(integer side)
        
        Args:
            side (int):

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

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

    def GetValueF(self, side):
        """float value = GetValueF(integer side)
        
        Args:
            side (int):

        Returns:
            value (float):
        """
        pass

    def GetValueI(self, side):
        """integer value = GetValueI(integer side)
        
        Args:
            side (int):

        Returns:
            value (int):
        """
        pass

    def GetWeight(self, side):
        """float weight = GetWeight(integer side)
        
        Args:
            side (int):

        Returns:
            weight (float):
        """
        pass

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

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

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

    def SetSlope(self, slope, side):
        """SetSlope(float slope,integer side)
        
        Args:
            slope (float):
            side (int):

        Returns:
            None
        """
        pass

    def SetSlopeType(self, type, side):
        """SetSlopeType(integer type,integer side)
        
        Args:
            type (int):
            side (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetValueF(self, value, side):
        """SetValueF(float value,integer side)
        
        Args:
            value (float):
            side (int):

        Returns:
            None
        """
        pass

    def SetValueI(self, value, side):
        """SetValueI(integer value,integer side)
        
        Args:
            value (int):
            side (int):

        Returns:
            None
        """
        pass

    def SetWeight(self, weight, reset, side):
        """SetWeight(float weight,integer reset,integer side)
        
        Args:
            weight (float):
            reset (int):
            side (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Kit:
    """Kit"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def SetEnabled(self, enabled):
        """SetEnabled(integer enabled)
        
        Args:
            enabled (int):

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LayerScan:
    """LayerScan"""
    def __init__(self, unknown=None):
        pass

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

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

    def GetState(self, index):
        """integer state = GetState(integer index)
        
        Args:
            index (int):

        Returns:
            state (int):
        """
        pass

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

        Returns:
            object (ChannelRead):
        """
        pass

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

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

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

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

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

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

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

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

    def MeshTransform(self, index):
        """matrix matrix = MeshTransform(integer index)
        
        Args:
            index (int):

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

    def SetMeshChange(self, index, edits):
        """SetMeshChange(integer index,integer edits)
        
        Args:
            index (int):
            edits (int):

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LayeredImage:
    """LayeredImage"""
    def __init__(self, unknown=None):
        pass

    def Blend(self, index):
        """(float opacity,integer mode) = Blend(integer index)
        
        Args:
            index (int):

        Returns:
            (float opacity,integer mode)
        """
        pass

    def ChannelName(self, layerIndex, channelIndex):
        """string name = ChannelName(integer layerIndex,integer channelIndex)
        
        Args:
            layerIndex (int):
            channelIndex (int):

        Returns:
            name (str):
        """
        pass

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

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

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

    def IsGroup(self, layerIndex):
        """integer isGroup = IsGroup(integer layerIndex)
        
        Args:
            layerIndex (int):

        Returns:
            isGroup (int):
        """
        pass

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

        Returns:
            name (str):
        """
        pass

    def Offset(self, index):
        """(integer x,integer y) = Offset(integer index)
        
        Args:
            index (int):

        Returns:
            (integer x,integer y)
        """
        pass

    def Parent(self, layerIndex):
        """integer parentIndex = Parent(integer layerIndex)
        
        Args:
            layerIndex (int):

        Returns:
            parentIndex (int):
        """
        pass

    def Size(self):
        """(integer w,integer h) = Size()
        
        Returns:
            (integer w,integer h)
        """
        pass

    def Type(self, index):
        """(integer flags,string type) = Type(integer index)
        
        Args:
            index (int):

        Returns:
            (integer flags,string type)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LayeredImageWrite:
    """LayeredImageWrite"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            index (int):
        """
        pass

    def AddLayer(self, image, name):
        """string channelNames = AddLayer(object image,string name)
        
        Args:
            image (lx.object.Image):
            name (str):

        Returns:
            channelNames (str):
        """
        pass

    def SetBlending(self, index, blend, mode):
        """SetBlending(integer index,float blend,string mode)
        
        Args:
            index (int):
            blend (float):
            mode (str):

        Returns:
            None
        """
        pass

    def SetOffset(self, index, x, y):
        """SetOffset(integer index,integer x,integer y)
        
        Args:
            index (int):
            x (int):
            y (int):

        Returns:
            None
        """
        pass

    def SetType(self, index, flags, type):
        """SetType(integer index,integer flags,string type)
        
        Args:
            index (int):
            flags (int):
            type (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LightSample:
    """LightSample"""
    def __init__(self, unknown=None):
        pass

    def Vertex(self, vertex):
        """Vertex(float[] vertex)
        
        Args:
            vertex (float[]):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Lighting:
    """Lighting"""
    def __init__(self, unknown=None):
        pass

    def EnvironmentEvaluate(self, vector, samples, flags):
        """vector lum = EnvironmentEvaluate(object vector,integer samples,integer flags)
        
        Args:
            vector (tuple):
            samples (int):
            flags (int):

        Returns:
            lum (tuple):
        """
        pass

    def GIRequired(self, vector):
        """integer = GIRequired(object vector)
        
        Args:
            vector (tuple):

        Returns:
            int
        """
        pass

    def LightSourceCount(self, vector):
        """integer num = LightSourceCount(object vector)
        
        Args:
            vector (tuple):

        Returns:
            num (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LineExecution:
    """LineExecution"""
    def __init__(self, unknown=None):
        pass

    def CookedLine(self, text):
        """CookedLine(string text)
        
        Args:
            text (str):

        Returns:
            None
        """
        pass

    def Info(self, text):
        """Info(string text)
        
        Args:
            text (str):

        Returns:
            None
        """
        pass

    def Message(self, message):
        """Message(object message)
        
        Args:
            message (message):

        Returns:
            None
        """
        pass

    def ResultHints(self, hints):
        """ResultHints(hints hints)
        
        Args:
            hints (hints):

        Returns:
            None
        """
        pass

    def Results(self, valArray):
        """Results(object valArray)
        
        Args:
            valArray (valArray):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LineInterpreter:
    """LineInterpreter"""
    def __init__(self, unknown=None):
        pass

    def Execute(self, line, execFlags, execution):
        """Execute(string line,integer execFlags,object execution)
        
        Args:
            line (str):
            execFlags (int):
            execution (execution):

        Returns:
            None
        """
        pass

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

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

        Returns:
            prompt (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LinkPacketTranslation:
    """LinkPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def From(self, packet):
        """(integer channel,Item object) = From(pointer packet)
        
        Args:
            packet (int):

        Returns:
            (integer channel,Item object)
        """
        pass

    def Packet(self, fromItem, fromChannel, toItem, toChannel):
        """pointer = Packet(object fromItem,integer fromChannel,object toItem,integer toChannel)
        
        Args:
            fromItem (fromItem):
            fromChannel (int):
            toItem (toItem):
            toChannel (int):

        Returns:
            int
        """
        pass

    def To(self, packet):
        """(integer channel,Item object) = To(pointer packet)
        
        Args:
            packet (int):

        Returns:
            (integer channel,Item object)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ListenerPort:
    """ListenerPort"""
    def __init__(self, unknown=None):
        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 set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Loader:
    """Loader"""
    def __init__(self, unknown=None):
        pass

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

    def LoadInstance(self, loadInfo, monitor):
        """Unknown object = LoadInstance(object loadInfo,object monitor)
        
        Args:
            loadInfo (loadInfo):
            monitor (monitor):

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

    def LoadObject(self, loadInfo, monitor, dest):
        """LoadObject(object loadInfo,object monitor,object dest)
        
        Args:
            loadInfo (loadInfo):
            monitor (monitor):
            dest (dest):

        Returns:
            None
        """
        pass

    def Recognize(self, filename, loadInfo):
        """Recognize(string filename,object loadInfo)
        
        Args:
            filename (str):
            loadInfo (loadInfo):

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LoaderInfo:
    """LoaderInfo"""
    def __init__(self, unknown=None):
        pass

    def SetClass(self, clsGUID):
        """SetClass(string clsGUID)
        
        Args:
            clsGUID (str):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetFormat(self, format):
        """SetFormat(string format)
        
        Args:
            format (str):

        Returns:
            None
        """
        pass

    def TestClass(self, clsGUID):
        """integer priority = TestClass(string clsGUID)
        
        Args:
            clsGUID (str):

        Returns:
            priority (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Locator:
    """Locator"""
    def __init__(self, unknown=None):
        pass

    def AddPostTransformItem(self, chanWrite, type, value):
        """(Item object,integer index) = AddPostTransformItem(object chanWrite,integer type,vector value)
        
        Args:
            chanWrite (chanWrite):
            type (int):
            value (tuple):

        Returns:
            (Item object,integer index)
        """
        pass

    def AddPreTransformItem(self, chanWrite, type, value):
        """(Item object,integer index) = AddPreTransformItem(object chanWrite,integer type,vector value)
        
        Args:
            chanWrite (chanWrite):
            type (int):
            value (tuple):

        Returns:
            (Item object,integer index)
        """
        pass

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

        Returns:
            (Item object,integer index)
        """
        pass

    def AppendTransformItem(self, chanWrite, type, value):
        """(Item object,integer index) = AppendTransformItem(object chanWrite,integer type,vector value)
        
        Args:
            chanWrite (chanWrite):
            type (int):
            value (tuple):

        Returns:
            (Item object,integer index)
        """
        pass

    def ExtractLocalPosition(self, chanRead):
        """vector pos = ExtractLocalPosition(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            pos (tuple):
        """
        pass

    def ExtractLocalRotation(self, chanRead):
        """matrix m3 = ExtractLocalRotation(object chanRead)
        
        Args:
            chanRead (chanRead):

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

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

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

    def LocalTransform(self, chanRead):
        """(matrix xfrm,vector pos) = LocalTransform(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            (matrix xfrm,vector pos)
        """
        pass

    def LocalTransform4(self, chanRead):
        """matrix xfrm4 = LocalTransform4(object chanRead)
        
        Args:
            chanRead (chanRead):

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

    def PrependTransformItem(self, chanWrite, type, value):
        """(Item object,integer index) = PrependTransformItem(object chanWrite,integer type,vector value)
        
        Args:
            chanWrite (chanWrite):
            type (int):
            value (tuple):

        Returns:
            (Item object,integer index)
        """
        pass

    def SetPosition(self, chanRead, chanWrite, pos, type, comp):
        """SetPosition(object chanRead,object chanWrite,vector pos,integer type,integer comp)
        
        Args:
            chanRead (chanRead):
            chanWrite (chanWrite):
            pos (tuple):
            type (int):
            comp (int):

        Returns:
            None
        """
        pass

    def SetRotation(self, chanRead, chanWrite, m3, type, comp):
        """SetRotation(object chanRead,object chanWrite,matrix m3,integer type,integer comp)
        
        Args:
            chanRead (chanRead):
            chanWrite (chanWrite):
            m3 (lx.object.Matrix):
            type (int):
            comp (int):

        Returns:
            None
        """
        pass

    def SetScale(self, chanRead, chanWrite, m4, type, comp):
        """SetScale(object chanRead,object chanWrite,matrix m4,integer type,integer comp)
        
        Args:
            chanRead (chanRead):
            chanWrite (chanWrite):
            m4 (lx.object.Matrix):
            type (int):
            comp (int):

        Returns:
            None
        """
        pass

    def SetTarget(self, target):
        """Item object = SetTarget(object target)
        
        Args:
            target (target):

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

    def SetTransformVector(self, chanWrite, type, value):
        """SetTransformVector(object chanWrite,integer type,vector value)
        
        Args:
            chanWrite (chanWrite):
            type (int):
            value (tuple):

        Returns:
            None
        """
        pass

    def Visible(self, chanRead):
        """boolean = Visible(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            bool
        """
        pass

    def WorldInvertTransform(self, chanRead):
        """(matrix xfrm,vector pos) = WorldInvertTransform(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            (matrix xfrm,vector pos)
        """
        pass

    def WorldTransform(self, chanRead):
        """(matrix xfrm,vector pos) = WorldTransform(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            (matrix xfrm,vector pos)
        """
        pass

    def WorldTransform4(self, chanRead):
        """matrix xfrm4 = WorldTransform4(object chanRead)
        
        Args:
            chanRead (chanRead):

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

    def ZeroTransform(self, chanRead, chanWrite, type):
        """ZeroTransform(object chanRead,object chanWrite,integer type)
        
        Args:
            chanRead (chanRead):
            chanWrite (chanWrite):
            type (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LocatorDest:
    """LocatorDest"""
    def __init__(self, unknown=None):
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Log:
    """Log"""
    def __init__(self, unknown=None):
        pass

    def AddEntry(self, entry):
        """AddEntry(object entry)
        
        Args:
            entry (entry):

        Returns:
            None
        """
        pass

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

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

        Returns:
            object (LogEntry):
        """
        pass

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

    def GetCurrentEntry(self):
        """LogEntry object = GetCurrentEntry()
        
        Returns:
            object (LogEntry):
        """
        pass

    def GetMaxEntries(self):
        """integer max = GetMaxEntries()
        
        Returns:
            max (int):
        """
        pass

    def GetRolling(self):
        """LogEntry object = GetRolling()
        
        Returns:
            object (LogEntry):
        """
        pass

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

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

        Returns:
            object
        """
        pass

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

    def RollEntry(self, entry):
        """RollEntry(object entry)
        
        Args:
            entry (entry):

        Returns:
            None
        """
        pass

    def SetMaxEntries(self, max):
        """SetMaxEntries(integer max)
        
        Args:
            max (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LogEntry:
    """LogEntry"""
    def __init__(self, unknown=None):
        pass

    def AddEntry(self, entry):
        """AddEntry(object entry)
        
        Args:
            entry (entry):

        Returns:
            None
        """
        pass

    def AddPair(self, name, value):
        """AddPair(string name,string value)
        
        Args:
            name (str):
            value (str):

        Returns:
            None
        """
        pass

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

        Returns:
            object (LogEntry):
        """
        pass

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

    def Class(self):
        """integer classType = Class()
        
        Returns:
            classType (int):
        """
        pass

    def Desc(self):
        """string desc = Desc()
        
        Returns:
            desc (str):
        """
        pass

    def InfoBlock(self):
        """LogInfoBlock object = InfoBlock()
        
        Returns:
            object (LogInfoBlock):
        """
        pass

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

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

    def Message(self):
        """string message = Message()
        
        Returns:
            message (str):
        """
        pass

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

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

        Returns:
            name (str):
        """
        pass

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

        Returns:
            value (str):
        """
        pass

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

        Returns:
            object
        """
        pass

    def SetDesc(self, desc):
        """SetDesc(string desc)
        
        Args:
            desc (str):

        Returns:
            None
        """
        pass

    def SetTitle(self, title):
        """SetTitle(string title)
        
        Args:
            title (str):

        Returns:
            None
        """
        pass

    def SetValue(self, name, index, value):
        """SetValue(string name,integer index,object value)
        
        Args:
            name (str):
            index (int):
            value (value):

        Returns:
            None
        """
        pass

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

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

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

    def TimeString(self):
        """string string = TimeString()
        
        Returns:
            string (str):
        """
        pass

    def Title(self):
        """string title = Title()
        
        Returns:
            title (str):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LogInfoBlock:
    """LogInfoBlock"""
    def __init__(self, unknown=None):
        pass

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

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

        Returns:
            name (str):
        """
        pass

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

        Returns:
            type (str):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class LogListener:
    """LogListener"""
    def __init__(self, unknown=None):
        pass

    def ChildEntryAdded(self, entry, parentEntry):
        """ChildEntryAdded(object entry,object parentEntry)
        
        Args:
            entry (entry):
            parentEntry (parentEntry):

        Returns:
            None
        """
        pass

    def EntryAdded(self, system, entry):
        """EntryAdded(object system,object entry)
        
        Args:
            system (system):
            entry (entry):

        Returns:
            None
        """
        pass

    def EntryDropped(self, system, entry):
        """EntryDropped(object system,object entry)
        
        Args:
            system (system):
            entry (entry):

        Returns:
            None
        """
        pass

    def RollingChildEntryAdded(self, entry, parentEntry):
        """RollingChildEntryAdded(object entry,object parentEntry)
        
        Args:
            entry (entry):
            parentEntry (parentEntry):

        Returns:
            None
        """
        pass

    def RollingEntryAdded(self, system, entry):
        """RollingEntryAdded(object system,object entry)
        
        Args:
            system (system):
            entry (entry):

        Returns:
            None
        """
        pass

    def RollingEntryDropped(self, system, entry):
        """RollingEntryDropped(object system,object entry)
        
        Args:
            system (system):
            entry (entry):

        Returns:
            None
        """
        pass

    def SystemAdded(self, system):
        """SystemAdded(object system)
        
        Args:
            system (system):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Matrix:
    """Matrix"""
    def __init__(self, unknown=None):
        pass

    def Get3(self):
        """matrix mat3 = Get3()
        
        Returns:
            mat3 (lx.object.Matrix):
        """
        pass

    def Get4(self):
        """matrix mat4 = Get4()
        
        Returns:
            mat4 (lx.object.Matrix):
        """
        pass

    def GetOffset(self):
        """vector offset = GetOffset()
        
        Returns:
            offset (tuple):
        """
        pass

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

    def Multiply3(self, mat3):
        """Multiply3(matrix mat3)
        
        Args:
            mat3 (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def Multiply4(self, mat4):
        """Multiply4(matrix mat4)
        
        Args:
            mat4 (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def MultiplyVector(self, vector):
        """vector result = MultiplyVector(vector vector)
        
        Args:
            vector (tuple):

        Returns:
            result (tuple):
        """
        pass

    def Set3(self, mat3):
        """Set3(matrix mat3)
        
        Args:
            mat3 (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def Set4(self, mat4):
        """Set4(matrix mat4)
        
        Args:
            mat4 (lx.object.Matrix):

        Returns:
            None
        """
        pass

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

    def SetOffset(self, offset):
        """SetOffset(vector offset)
        
        Args:
            offset (tuple):

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MergedDirCacheEntry:
    """MergedDirCacheEntry"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            object (DirCacheEntry):
        """
        pass

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

    def Parent(self):
        """DirCacheEntry object = Parent()
        
        Returns:
            object (DirCacheEntry):
        """
        pass

    def Path(self):
        """string = Path()
        
        Returns:
            str
        """
        pass

    def UserPath(self):
        """string = UserPath()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MergedFileSysDest:
    """MergedFileSysDest"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

    def Path(self):
        """string = Path()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Mesh:
    """Mesh"""
    def __init__(self, unknown=None):
        pass

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

    def BoundingBox(self, pick):
        """bounds bbox = BoundingBox(integer pick)
        
        Args:
            pick (int):

        Returns:
            bbox (bounds):
        """
        pass

    def ChangeEvent(self, event):
        """ChangeEvent(integer event)
        
        Args:
            event (int):

        Returns:
            None
        """
        pass

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

    def EdgeAccessor(self):
        """Edge object = EdgeAccessor()
        
        Returns:
            object (Edge):
        """
        pass

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

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

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

    def MaxPointPolygons(self, pick):
        """integer count = MaxPointPolygons(integer pick)
        
        Args:
            pick (int):

        Returns:
            count (int):
        """
        pass

    def MaxPolygonSize(self, pick):
        """integer count = MaxPolygonSize(integer pick)
        
        Args:
            pick (int):

        Returns:
            count (int):
        """
        pass

    def Merge(self, other, flags):
        """Merge(object other,integer flags)
        
        Args:
            other (other):
            flags (int):

        Returns:
            None
        """
        pass

    def MergeWithTransform(self, other, xfrm, flags):
        """MergeWithTransform(object other,matrix xfrm,integer flags)
        
        Args:
            other (other):
            xfrm (lx.object.Matrix):
            flags (int):

        Returns:
            None
        """
        pass

    def MeshMapAccessor(self):
        """MeshMap object = MeshMapAccessor()
        
        Returns:
            object (MeshMap):
        """
        pass

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

    def PSUBDispLayerEnable(self, index):
        """integer enable = PSUBDispLayerEnable(integer index)
        
        Args:
            index (int):

        Returns:
            enable (int):
        """
        pass

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

        Returns:
            index (int):
        """
        pass

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

        Returns:
            str
        """
        pass

    def PSUBDispLayerOpacity(self, index):
        """float opacity = PSUBDispLayerOpacity(integer index)
        
        Args:
            index (int):

        Returns:
            opacity (float):
        """
        pass

    def PSUBDispLayerSetOpacity(self, index, opacity):
        """PSUBDispLayerSetOpacity(integer index,float opacity)
        
        Args:
            index (int):
            opacity (float):

        Returns:
            None
        """
        pass

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

    def PSUBGetBoundRule(self):
        """integer bound = PSUBGetBoundRule()
        
        Returns:
            bound (int):
        """
        pass

    def PSUBGetCurrentLevel(self):
        """integer n = PSUBGetCurrentLevel()
        
        Returns:
            n (int):
        """
        pass

    def PSUBGetLevel(self):
        """integer n = PSUBGetLevel()
        
        Returns:
            n (int):
        """
        pass

    def PSUBSetBoundRule(self, bound):
        """PSUBSetBoundRule(integer bound)
        
        Args:
            bound (int):

        Returns:
            None
        """
        pass

    def PSUBSetCurrentLevel(self, n):
        """PSUBSetCurrentLevel(integer n)
        
        Args:
            n (int):

        Returns:
            None
        """
        pass

    def PSUBSetLevel(self, n):
        """PSUBSetLevel(integer n)
        
        Args:
            n (int):

        Returns:
            None
        """
        pass

    def PSUBSetSubdivObj(self, subObj):
        """PSUBSetSubdivObj(object subObj)
        
        Args:
            subObj (subObj):

        Returns:
            None
        """
        pass

    def PTagByIndex(self, type, index):
        """string tag = PTagByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            tag (str):
        """
        pass

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

        Returns:
            int
        """
        pass

    def PointAccessor(self):
        """Point object = PointAccessor()
        
        Returns:
            object (Point):
        """
        pass

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

    def PolyTagSetDefault(self, type, tag):
        """PolyTagSetDefault(integer type,string tag)
        
        Args:
            type (int):
            tag (str):

        Returns:
            None
        """
        pass

    def PolygonAccessor(self):
        """Polygon object = PolygonAccessor()
        
        Returns:
            object (Polygon):
        """
        pass

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

    def SUBDGetLevel(self):
        """integer n = SUBDGetLevel()
        
        Returns:
            n (int):
        """
        pass

    def SUBDGetLinearUV(self):
        """integer isLinear = SUBDGetLinearUV()
        
        Returns:
            isLinear (int):
        """
        pass

    def SUBDSetLevel(self, n):
        """SUBDSetLevel(integer n)
        
        Args:
            n (int):

        Returns:
            None
        """
        pass

    def SUBDSetLinearUV(self, isLinear):
        """SUBDSetLinearUV(integer isLinear)
        
        Args:
            isLinear (int):

        Returns:
            None
        """
        pass

    def SetMeshEdits(self, edits):
        """SetMeshEdits(integer edits)
        
        Args:
            edits (int):

        Returns:
            None
        """
        pass

    def TestSameMesh(self, other):
        """boolean = TestSameMesh(object other)
        
        Args:
            other (other):

        Returns:
            bool
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshBlend:
    """MeshBlend"""
    def __init__(self, unknown=None):
        pass

    def BlendMesh(self, t):
        """Unknown object = BlendMesh(float t)
        
        Args:
            t (float):

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

    def EnumeratePoints(self, source, target, visitor):
        """EnumeratePoints(object source,object target,object visitor)
        
        Args:
            source (lxu.object.Item):
            target (target):
            visitor (visitor):

        Returns:
            None
        """
        pass

    def EnumeratePolygons(self, source, target, visitor):
        """EnumeratePolygons(object source,object target,object visitor)
        
        Args:
            source (lxu.object.Item):
            target (target):
            visitor (visitor):

        Returns:
            None
        """
        pass

    def GetPoint(self, source):
        """id target = GetPoint(id source)
        
        Args:
            source (id):

        Returns:
            target (id):
        """
        pass

    def GetPolygon(self, source):
        """id target = GetPolygon(id source)
        
        Args:
            source (id):

        Returns:
            target (id):
        """
        pass

    def SetPoint(self, source, target):
        """SetPoint(id source,id target)
        
        Args:
            source (id):
            target (id):

        Returns:
            None
        """
        pass

    def SetPolygon(self, source, target):
        """SetPolygon(id source,id target)
        
        Args:
            source (id):
            target (id):

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshDest:
    """MeshDest"""
    def __init__(self, unknown=None):
        pass

    def HitNormal(self):
        """vector nrm = HitNormal()
        
        Returns:
            nrm (tuple):
        """
        pass

    def HitPosition(self):
        """vector pos = HitPosition()
        
        Returns:
            pos (tuple):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshElementGroup:
    """MeshElementGroup"""
    def __init__(self, unknown=None):
        pass

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

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

        Returns:
            name (str):
        """
        pass

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

        Returns:
            username (str):
        """
        pass

    def TestEdge(self, index, edge):
        """boolean = TestEdge(integer index,id edge)
        
        Args:
            index (int):
            edge (id):

        Returns:
            bool
        """
        pass

    def TestPoint(self, index, point):
        """boolean = TestPoint(integer index,id point)
        
        Args:
            index (int):
            point (id):

        Returns:
            bool
        """
        pass

    def TestPolygon(self, index, polygon):
        """boolean = TestPolygon(integer index,id polygon)
        
        Args:
            index (int):
            polygon (id):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshFilter:
    """MeshFilter"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self, mesh, tracker):
        """Evaluate(object mesh,object tracker)
        
        Args:
            mesh (lxu.object.Mesh):
            tracker (tracker):

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshFilterBBox:
    """MeshFilterBBox"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self):
        """bounds box = Evaluate()
        
        Returns:
            box (bounds):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshFilterBlend:
    """MeshFilterBlend"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self, other, blend):
        """Evaluate(object other,object blend)
        
        Args:
            other (other):
            blend (blend):

        Returns:
            None
        """
        pass

    def Generate(self, other):
        """MeshBlend object = Generate(object other)
        
        Args:
            other (other):

        Returns:
            object (MeshBlend):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshFilterIdent:
    """MeshFilterIdent"""
    def __init__(self, unknown=None):
        pass

    def Generate(self, ident):
        """Mesh object = Generate(string ident)
        
        Args:
            ident (str):

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshInfluence:
    """MeshInfluence"""
    def __init__(self, unknown=None):
        pass

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

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

    def MeshChange(self, index, change):
        """MeshChange(integer index,integer change)
        
        Args:
            index (int):
            change (int):

        Returns:
            None
        """
        pass

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

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

        Returns:
            int
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetTransform(self, index):
        """matrix xfrm = SetTransform(integer index)
        
        Args:
            index (int):

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshLayerPreDest:
    """MeshLayerPreDest"""
    def __init__(self, unknown=None):
        pass

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

    def ShaderDest(self):
        """ShaderPreDest object = ShaderDest()
        
        Returns:
            object (ShaderPreDest):
        """
        pass

    def Transform(self):
        """matrix xform = Transform()
        
        Returns:
            xform (lx.object.Matrix):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshMap:
    """MeshMap"""
    def __init__(self, unknown=None):
        pass

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

    def Dimension(self):
        """integer dimension = Dimension()
        
        Returns:
            dimension (int):
        """
        pass

    def Enumerate(self, mode, visitor, monitor):
        """Enumerate(integer mode,object visitor,object monitor)
        
        Args:
            mode (int):
            visitor (visitor):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def EnumerateContinuous(self, visitor, point):
        """EnumerateContinuous(object visitor,object point)
        
        Args:
            visitor (visitor):
            point (point):

        Returns:
            None
        """
        pass

    def EnumerateDiscontinuous(self, visitor, point, poly):
        """EnumerateDiscontinuous(object visitor,object point,object poly)
        
        Args:
            visitor (visitor):
            point (point):
            poly (poly):

        Returns:
            None
        """
        pass

    def EnumerateEdges(self, visitor, edge):
        """EnumerateEdges(object visitor,object edge)
        
        Args:
            visitor (visitor):
            edge (edge):

        Returns:
            None
        """
        pass

    def EnumerateUVSeamEdges(self, visitor, edge, poly):
        """EnumerateUVSeamEdges(object visitor,object edge,object poly)
        
        Args:
            visitor (visitor):
            edge (edge):
            poly (poly):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def ID(self):
        """id = ID()
        
        Returns:
            id
        """
        pass

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

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

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

    def New(self, type, name):
        """id mapID = New(integer type,string name)
        
        Args:
            type (int):
            name (str):

        Returns:
            mapID (id):
        """
        pass

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

    def Select(self, map):
        """Select(id map)
        
        Args:
            map (id):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def Spawn(self):
        """MeshMap object = Spawn()
        
        Returns:
            object (MeshMap):
        """
        pass

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

    def UVBoundingBox(self):
        """bounds bbox = UVBoundingBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def UVSeamOppositeEdge(self, originalEdge, originalPoly):
        """(id opppositePoly,integer isReverse) = UVSeamOppositeEdge(id originalEdge,id originalPoly)
        
        Args:
            originalEdge (id):
            originalPoly (id):

        Returns:
            (id opppositePoly,integer isReverse)
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshOpDest:
    """MeshOpDest"""
    def __init__(self, unknown=None):
        pass

    def Graph(self):
        """string = Graph()
        
        Returns:
            str
        """
        pass

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshOperation:
    """MeshOperation"""
    def __init__(self, unknown=None):
        pass

    def Blend(self, other, blend):
        """Blend(object other,object blend)
        
        Args:
            other (other):
            blend (blend):

        Returns:
            None
        """
        pass

    def Clone(self, target, source):
        """Unknown object = Clone(object target,object source)
        
        Args:
            target (target):
            source (lxu.object.Item):

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

    def Compare(self, other):
        """integer = Compare(object other)
        
        Args:
            other (other):

        Returns:
            int
        """
        pass

    def Convert(self, other):
        """Convert(object other)
        
        Args:
            other (other):

        Returns:
            None
        """
        pass

    def Evaluate(self, mesh, type, mode):
        """Evaluate(object mesh,integer type,integer mode)
        
        Args:
            mesh (lxu.object.Mesh):
            type (int):
            mode (int):

        Returns:
            None
        """
        pass

    def ReEvaluate(self, mesh, type):
        """ReEvaluate(object mesh,integer type)
        
        Args:
            mesh (lxu.object.Mesh):
            type (int):

        Returns:
            None
        """
        pass

    def SetTransform(self, matrix):
        """SetTransform(matrix matrix)
        
        Args:
            matrix (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshTracker:
    """MeshTracker"""
    def __init__(self, unknown=None):
        pass

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

    def AddPoint(self, point, change):
        """AddPoint(id point,integer change)
        
        Args:
            point (id):
            change (int):

        Returns:
            None
        """
        pass

    def AddPolygon(self, poly, change):
        """AddPolygon(id poly,integer change)
        
        Args:
            poly (id):
            change (int):

        Returns:
            None
        """
        pass

    def Changes(self):
        """integer edit = Changes()
        
        Returns:
            edit (int):
        """
        pass

    def EnumeratePoints(self, change, visitor, point):
        """EnumeratePoints(integer change,object visitor,object point)
        
        Args:
            change (int):
            visitor (visitor):
            point (point):

        Returns:
            None
        """
        pass

    def EnumeratePolygons(self, change, visitor, poly):
        """EnumeratePolygons(integer change,object visitor,object poly)
        
        Args:
            change (int):
            visitor (visitor):
            poly (poly):

        Returns:
            None
        """
        pass

    def Filter(self):
        """integer filter = Filter()
        
        Returns:
            filter (int):
        """
        pass

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

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

    def SetChange(self, change):
        """SetChange(integer change)
        
        Args:
            change (int):

        Returns:
            None
        """
        pass

    def SetFilter(self, filter):
        """SetFilter(integer filter)
        
        Args:
            filter (int):

        Returns:
            None
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class MeshXtraData:
    """MeshXtraData"""
    def __init__(self, unknown=None):
        pass

    def ClearPoint(self, point):
        """ClearPoint(id point)
        
        Args:
            point (id):

        Returns:
            None
        """
        pass

    def ClearPolygon(self, poly):
        """ClearPolygon(id poly)
        
        Args:
            poly (id):

        Returns:
            None
        """
        pass

    def GetPointObject(self, point):
        """Unknown object = GetPointObject(id point)
        
        Args:
            point (id):

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

    def GetPolygonObject(self, poly):
        """Unknown object = GetPolygonObject(id poly)
        
        Args:
            poly (id):

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

    def SetPointData(self, point, data):
        """SetPointData(id point,pointer data)
        
        Args:
            point (id):
            data (int):

        Returns:
            None
        """
        pass

    def SetPointObject(self, point, obj):
        """SetPointObject(id point,object obj)
        
        Args:
            point (id):
            obj (obj):

        Returns:
            None
        """
        pass

    def SetPolygonData(self, poly, data):
        """SetPolygonData(id poly,pointer data)
        
        Args:
            poly (id):
            data (int):

        Returns:
            None
        """
        pass

    def SetPolygonObject(self, poly, obj):
        """SetPolygonObject(id poly,object obj)
        
        Args:
            poly (id):
            obj (obj):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Message:
    """Message"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def SetArgumentFloat(self, arg, value):
        """SetArgumentFloat(integer arg,float value)
        
        Args:
            arg (int):
            value (float):

        Returns:
            None
        """
        pass

    def SetArgumentInt(self, arg, value):
        """SetArgumentInt(integer arg,integer value)
        
        Args:
            arg (int):
            value (int):

        Returns:
            None
        """
        pass

    def SetArgumentObject(self, arg, object):
        """SetArgumentObject(integer arg,object object)
        
        Args:
            arg (int):
            object (object):

        Returns:
            None
        """
        pass

    def SetArgumentString(self, arg, string):
        """SetArgumentString(integer arg,string string)
        
        Args:
            arg (int):
            string (str):

        Returns:
            None
        """
        pass

    def SetCode(self, code):
        """SetCode(integer code)
        
        Args:
            code (int):

        Returns:
            None
        """
        pass

    def SetMessage(self, table, name, id):
        """SetMessage(string table,string name,integer id)
        
        Args:
            table (str):
            name (str):
            id (int):

        Returns:
            None
        """
        pass

    def SetMessageResult(self, id):
        """SetMessageResult(integer id)
        
        Args:
            id (int):

        Returns:
            None
        """
        pass

    def Table(self):
        """string table = Table()
        
        Returns:
            table (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Modifier:
    """Modifier"""
    def __init__(self, unknown=None):
        pass

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

    def Free(self, cache):
        """Free(pointer cache)
        
        Args:
            cache (int):

        Returns:
            None
        """
        pass

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

        Returns:
            bool
        """
        pass

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

        Returns:
            (integer attr,Item object)
        """
        pass

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

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

        Returns:
            bool
        """
        pass

    def Validate(self, item, index, rc):
        """Validate(object item,integer index,integer rc)
        
        Args:
            item (lxu.object.Item):
            index (int):
            rc (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Module:
    """Module"""
    def __init__(self, unknown=None):
        pass

    def Generate(self, name, iid):
        """Unknown object = Generate(string name,string iid)
        
        Args:
            name (str):
            iid (str):

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

    def GetTags(self, name, iid):
        """StringTag object = GetTags(string name,string iid)
        
        Args:
            name (str):
            iid (str):

        Returns:
            object (StringTag):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Monitor:
    """Monitor"""
    def __init__(self, unknown=None):
        pass

    def Increment(self, count):
        """Increment(integer count)
        
        Args:
            count (int):

        Returns:
            None
        """
        pass

    def Initialize(self, count):
        """Initialize(integer count)
        
        Args:
            count (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class NavigationListener:
    """NavigationListener"""
    def __init__(self, unknown=None):
        pass

    def Delta(self, view, item, hot, pos, rot, zoom):
        """Delta(object view,object item,integer hot,vector pos,matrix rot,float zoom)
        
        Args:
            view (view):
            item (lxu.object.Item):
            hot (int):
            pos (tuple):
            rot (lx.object.Matrix):
            zoom (float):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def Move(self, view, item, hot, pos, rot, zoom):
        """Move(object view,object item,integer hot,vector pos,matrix rot,float zoom)
        
        Args:
            view (view):
            item (lxu.object.Item):
            hot (int):
            pos (tuple):
            rot (lx.object.Matrix):
            zoom (float):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class NeedContext:
    """NeedContext"""
    def __init__(self, unknown=None):
        pass

    def SetContext(self, app):
        """SetContext(object app)
        
        Args:
            app (app):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class NodePacketTranslation:
    """NodePacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Node(self, packet):
        """Node object = Node(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (Node):
        """
        pass

    def Packet(self, node):
        """pointer = Packet(object node)
        
        Args:
            node (node):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Notifier:
    """Notifier"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

    def Args(self):
        """string args = Args()
        
        Returns:
            args (str):
        """
        pass

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

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

        Returns:
            None
        """
        pass

    def SetArgs(self, args):
        """SetArgs(string args)
        
        Args:
            args (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Object:
    """Object"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

    def Identifier(self):
        """string id = Identifier()
        
        Returns:
            id (str):
        """
        pass

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

        Returns:
            guid (str):
        """
        pass

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

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Package:
    """Package"""
    def __init__(self, unknown=None):
        pass

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

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetupChannels(self, addChan):
        """SetupChannels(object addChan)
        
        Args:
            addChan (addChan):

        Returns:
            None
        """
        pass

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

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PackageInstance:
    """PackageInstance"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

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

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

        Returns:
            None
        """
        pass

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

    def Newborn(self, original, flags):
        """Newborn(object original,integer flags)
        
        Args:
            original (original):
            flags (int):

        Returns:
            None
        """
        pass

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

    def SynthName(self):
        """string = SynthName()
        
        Returns:
            str
        """
        pass

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

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PacketEffect:
    """PacketEffect"""
    def __init__(self, unknown=None):
        pass

    def ByIndex(self, index):
        """(string name,string typeName,integer type) = ByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (string name,string typeName,integer type)
        """
        pass

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

    def Get(self, index, packet, item):
        """float val = Get(integer index,pointer packet,pointer item)
        
        Args:
            index (int):
            packet (int):
            item (int):

        Returns:
            val (float):
        """
        pass

    def Packet(self):
        """string packet = Packet()
        
        Returns:
            packet (str):
        """
        pass

    def Set(self, index, packet, val, item):
        """Set(integer index,pointer packet,float[] val,pointer item)
        
        Args:
            index (int):
            packet (int):
            val (float[]):
            item (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PaintBrushPacket:
    """PaintBrushPacket"""
    def __init__(self, unknown=None):
        pass

    def BBox(self, toolVector, center, size):
        """(integer,bounds bbox) = BBox(object toolVector,vector center,float size)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            size (float):

        Returns:
            bbox) ((integer,bounds):
        """
        pass

    def Eval3D(self, toolVector, center, wpos, bpos, rad):
        """(float,float rgba) = Eval3D(object toolVector,vector center,vector wpos,vector bpos,float rad)
        
        Args:
            toolVector (toolVector):
            center (tuple):
            wpos (tuple):
            bpos (tuple):
            rad (float):

        Returns:
            rgba) ((float,float):
        """
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PaintInkPacket:
    """PaintInkPacket"""
    def __init__(self, unknown=None):
        pass

    def Color(self, toolVector, flags):
        """(integer,vector rgba) = Color(object toolVector,integer flags)
        
        Args:
            toolVector (toolVector):
            flags (int):

        Returns:
            rgba) ((integer,vector):
        """
        pass

    def Flags(self, toolVector):
        """integer = Flags(object toolVector)
        
        Args:
            toolVector (toolVector):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PaintNozzlePacket:
    """PaintNozzlePacket"""
    def __init__(self, unknown=None):
        pass

    def Jitter(self, toolVector, brushSize):
        """(integer,integer xj,integer yj) = Jitter(object toolVector,float brushSize)
        
        Args:
            toolVector (toolVector):
            brushSize (float):

        Returns:
            (integer,integer xj,integer yj)
        """
        pass

    def Nozzle(self, toolVector):
        """(integer,float strength,float size,float rotation) = Nozzle(object toolVector)
        
        Args:
            toolVector (toolVector):

        Returns:
            (integer,float strength,float size,float rotation)
        """
        pass

    def Paint(self, toolVector, brushSize):
        """integer = Paint(object toolVector,float brushSize)
        
        Args:
            toolVector (toolVector):
            brushSize (float):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ParticleCoOperator:
    """ParticleCoOperator"""
    def __init__(self, unknown=None):
        pass

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

    def Initialize(self, eval):
        """Initialize(object eval)
        
        Args:
            eval (eval):

        Returns:
            None
        """
        pass

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

    def Step(self, dT):
        """Step(float dT)
        
        Args:
            dT (float):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ParticleEvalFrame:
    """ParticleEvalFrame"""
    def __init__(self, unknown=None):
        pass

    def AddParticle(self, state):
        """integer index = AddParticle(float[] state)
        
        Args:
            state (float[]):

        Returns:
            index (int):
        """
        pass

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

    def GetVector(self, index):
        """float vector = GetVector(integer index)
        
        Args:
            index (int):

        Returns:
            vector (float):
        """
        pass

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

        Returns:
            int
        """
        pass

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

        Returns:
            None
        """
        pass

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

    def Neighbors(self, maxDist, maxCount):
        """(vector pos,integer index,float dist,integer count) = Neighbors(float maxDist,integer maxCount)
        
        Args:
            maxDist (float):
            maxCount (int):

        Returns:
            (vector pos,integer index,float dist,integer count)
        """
        pass

    def SetVector(self, index, vector):
        """SetVector(integer index,float[] vector)
        
        Args:
            index (int):
            vector (float[]):

        Returns:
            None
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ParticleFilter:
    """ParticleFilter"""
    def __init__(self, unknown=None):
        pass

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

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

    def Frame(self, stage):
        """Frame(integer stage)
        
        Args:
            stage (int):

        Returns:
            None
        """
        pass

    def Initialize(self, vertex, frame, time):
        """Initialize(object vertex,object frame,float time)
        
        Args:
            vertex (vertex):
            frame (frame):
            time (float):

        Returns:
            None
        """
        pass

    def Particle(self, stage, vertex):
        """Particle(integer stage,float[] vertex)
        
        Args:
            stage (int):
            vertex (float[]):

        Returns:
            None
        """
        pass

    def Step(self, other, dt):
        """Step(object other,float dt)
        
        Args:
            other (other):
            dt (float):

        Returns:
            None
        """
        pass

    def Vertex(self, full):
        """object = Vertex(object full)
        
        Args:
            full (full):

        Returns:
            object
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ParticleGeneratorPacket:
    """ParticleGeneratorPacket"""
    def __init__(self, unknown=None):
        pass

    def Count(self, vts):
        """integer = Count(object vts)
        
        Args:
            vts (vts):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ParticleItem:
    """ParticleItem"""
    def __init__(self, unknown=None):
        pass

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

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

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

        Returns:
            index (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PathGeneratorPacket:
    """PathGeneratorPacket"""
    def __init__(self, unknown=None):
        pass

    def Bank(self, vts, t):
        """float = Bank(object vts,float t)
        
        Args:
            vts (vts):
            t (float):

        Returns:
            float
        """
        pass

    def Count(self, vts):
        """integer = Count(object vts)
        
        Args:
            vts (vts):

        Returns:
            int
        """
        pass

    def Current(self, vts):
        """integer = Current(object vts)
        
        Args:
            vts (vts):

        Returns:
            int
        """
        pass

    def KnotDataSet(self, gen):
        """KnotDataSet(object gen)
        
        Args:
            gen (gen):

        Returns:
            None
        """
        pass

    def Length(self, vts, t0, t1):
        """float = Length(object vts,float t0,float t1)
        
        Args:
            vts (vts):
            t0 (float):
            t1 (float):

        Returns:
            float
        """
        pass

    def Tangent(self, vts, t):
        """float tan = Tangent(object vts,float t)
        
        Args:
            vts (vts):
            t (float):

        Returns:
            tan (float):
        """
        pass

    def Value(self, vts, t):
        """vector pos = Value(object vts,float t)
        
        Args:
            vts (vts):
            t (float):

        Returns:
            pos (tuple):
        """
        pass

    def Walk(self, vts, pathStep, angle, ti, tf):
        """integer = Walk(object vts,object pathStep,float angle,float ti,float tf)
        
        Args:
            vts (vts):
            pathStep (pathStep):
            angle (float):
            ti (float):
            tf (float):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PathStep:
    """PathStep"""
    def __init__(self, unknown=None):
        pass

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

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

    def Step(self, t):
        """(integer,vector pos) = Step(float t)
        
        Args:
            t (float):

        Returns:
            pos) ((integer,vector):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Pattern:
    """Pattern"""
    def __init__(self, unknown=None):
        pass

    def GenerateSequenceString(self, start, end):
        """string = GenerateSequenceString(integer start,integer end)
        
        Args:
            start (int):
            end (int):

        Returns:
            str
        """
        pass

    def Test(self, index, offset):
        """boolean = Test(integer index,integer offset)
        
        Args:
            index (int):
            offset (int):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PersistenceClient:
    """PersistenceClient"""
    def __init__(self, unknown=None):
        pass

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PersistentEntry:
    """PersistentEntry"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

    def Hash(self):
        """string key = Hash()
        
        Returns:
            key (str):
        """
        pass

    def Insert(self, key):
        """Insert(string key)
        
        Args:
            key (str):

        Returns:
            None
        """
        pass

    def Lookup(self, key):
        """Lookup(string key)
        
        Args:
            key (str):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PivotPacketTranslation:
    """PivotPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

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

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

        Returns:
            int
        """
        pass

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

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Point:
    """Point"""
    def __init__(self, unknown=None):
        pass

    def ClearMapValue(self, map):
        """ClearMapValue(id map)
        
        Args:
            map (id):

        Returns:
            None
        """
        pass

    def Copy(self):
        """id pointID = Copy()
        
        Returns:
            pointID (id):
        """
        pass

    def Corner(self):
        """vector pos = Corner()
        
        Returns:
            pos (tuple):
        """
        pass

    def EdgeByIndex(self, index):
        """id edgeID = EdgeByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            edgeID (id):
        """
        pass

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

    def Enumerate(self, mode, visitor, monitor):
        """Enumerate(integer mode,object visitor,object monitor)
        
        Args:
            mode (int):
            visitor (visitor):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def ID(self):
        """id = ID()
        
        Returns:
            id
        """
        pass

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

    def MapEvaluate(self, map, value):
        """boolean = MapEvaluate(id map,float[] value)
        
        Args:
            map (id):
            value (float[]):

        Returns:
            bool
        """
        pass

    def MapValue(self, map, value):
        """boolean = MapValue(id map,float[] value)
        
        Args:
            map (id):
            value (float[]):

        Returns:
            bool
        """
        pass

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

    def New(self, pos):
        """id pointID = New(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            pointID (id):
        """
        pass

    def Normal(self, pol):
        """vector normal = Normal(id pol)
        
        Args:
            pol (id):

        Returns:
            normal (tuple):
        """
        pass

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

    def Part(self):
        """integer part = Part()
        
        Returns:
            part (int):
        """
        pass

    def PointByIndex(self, index):
        """id pointID = PointByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            pointID (id):
        """
        pass

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

    def PolygonByIndex(self, index):
        """id polygonID = PolygonByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            polygonID (id):
        """
        pass

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

    def Pos(self):
        """vector pos = Pos()
        
        Returns:
            pos (tuple):
        """
        pass

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

    def Select(self, point):
        """Select(id point)
        
        Args:
            point (id):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SelectPolygonVertex(self, polygon, index):
        """SelectPolygonVertex(id polygon,integer index)
        
        Args:
            polygon (id):
            index (int):

        Returns:
            None
        """
        pass

    def SetMapValue(self, map, value):
        """SetMapValue(id map,float[] value)
        
        Args:
            map (id):
            value (float[]):

        Returns:
            None
        """
        pass

    def SetMarks(self, set):
        """SetMarks(integer set)
        
        Args:
            set (int):

        Returns:
            None
        """
        pass

    def SetPos(self, pos):
        """SetPos(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            None
        """
        pass

    def Spawn(self):
        """Point object = Spawn()
        
        Returns:
            object (Point):
        """
        pass

    def Symmetry(self):
        """id pointID = Symmetry()
        
        Returns:
            pointID (id):
        """
        pass

    def TestMarks(self, mode):
        """boolean = TestMarks(integer mode)
        
        Args:
            mode (int):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PointCacheItem:
    """PointCacheItem"""
    def __init__(self, unknown=None):
        pass

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

    def Initialize(self, vdesc, attr, index, time, sample):
        """Initialize(object vdesc,object attr,integer index,float time,float sample)
        
        Args:
            vdesc (vdesc):
            attr (attr):
            index (int):
            time (float):
            sample (float):

        Returns:
            None
        """
        pass

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

        Returns:
            index (int):
        """
        pass

    def SaveFrame(self, pobj, time):
        """SaveFrame(object pobj,float time)
        
        Args:
            pobj (pobj):
            time (float):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Polygon:
    """Polygon"""
    def __init__(self, unknown=None):
        pass

    def AddContourEdge(self, startPt, endPt):
        """AddContourEdge(id startPt,id endPt)
        
        Args:
            startPt (id):
            endPt (id):

        Returns:
            None
        """
        pass

    def Area(self):
        """float area = Area()
        
        Returns:
            area (float):
        """
        pass

    def ClearMapValue(self, point, map):
        """ClearMapValue(id point,id map)
        
        Args:
            point (id):
            map (id):

        Returns:
            None
        """
        pass

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

    def Closest(self, maxDist, pos):
        """(boolean,vector hitPos,vector hitNorm,float hitDist) = Closest(float maxDist,vector pos)
        
        Args:
            maxDist (float):
            pos (tuple):

        Returns:
            (boolean,vector hitPos,vector hitNorm,float hitDist)
        """
        pass

    def EdgeIndex(self, edgeID):
        """integer index = EdgeIndex(id edgeID)
        
        Args:
            edgeID (id):

        Returns:
            index (int):
        """
        pass

    def Enumerate(self, mode, visitor, monitor):
        """Enumerate(integer mode,object visitor,object monitor)
        
        Args:
            mode (int):
            visitor (visitor):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def EnumerateBBox(self, mode, visitor, min, max):
        """EnumerateBBox(integer mode,object visitor,vector min,vector max)
        
        Args:
            mode (int):
            visitor (visitor):
            min (tuple):
            max (tuple):

        Returns:
            None
        """
        pass

    def EnumerateBin(self, mode, visitor, bin):
        """EnumerateBin(integer mode,object visitor,object bin)
        
        Args:
            mode (int):
            visitor (visitor):
            bin (bin):

        Returns:
            None
        """
        pass

    def EnumerateByPTag(self, mode, type, tag, visitor):
        """EnumerateByPTag(integer mode,integer type,string tag,object visitor)
        
        Args:
            mode (int):
            type (int):
            tag (str):
            visitor (visitor):

        Returns:
            None
        """
        pass

    def EnumerateByUV(self, mode, vMapName, quality, uv, visitor):
        """EnumerateByUV(integer mode,string vMapName,integer quality,vector uv,object visitor)
        
        Args:
            mode (int):
            vMapName (str):
            quality (int):
            uv (tuple):
            visitor (visitor):

        Returns:
            None
        """
        pass

    def EnumerateLine(self, mode, visitor, org, dir):
        """EnumerateLine(integer mode,object visitor,vector org,vector dir)
        
        Args:
            mode (int):
            visitor (visitor):
            org (tuple):
            dir (tuple):

        Returns:
            None
        """
        pass

    def EnumerateRay(self, mode, visitor, org, ray):
        """EnumerateRay(integer mode,object visitor,vector org,vector ray)
        
        Args:
            mode (int):
            visitor (visitor):
            org (tuple):
            ray (tuple):

        Returns:
            None
        """
        pass

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

    def GenerateContour(self, type):
        """id polygonID = GenerateContour(integer type)
        
        Args:
            type (int):

        Returns:
            polygonID (id):
        """
        pass

    def GenerateContourProto(self):
        """id polygonID = GenerateContourProto()
        
        Returns:
            polygonID (id):
        """
        pass

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

    def GoodPoint(self, points, nPoints):
        """integer index = GoodPoint(id[] points,integer nPoints)
        
        Args:
            points (id[]):
            nPoints (int):

        Returns:
            index (int):
        """
        pass

    def ID(self):
        """id = ID()
        
        Returns:
            id
        """
        pass

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

    def IntersectRay(self, pos, dir):
        """(boolean,vector hitNorm,float hitDist) = IntersectRay(vector pos,vector dir)
        
        Args:
            pos (tuple):
            dir (tuple):

        Returns:
            (boolean,vector hitNorm,float hitDist)
        """
        pass

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

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

    def MapEvaluate(self, map, point, value):
        """boolean = MapEvaluate(id map,id point,float[] value)
        
        Args:
            map (id):
            point (id):
            value (float[]):

        Returns:
            bool
        """
        pass

    def MapValue(self, map, point, value):
        """boolean = MapValue(id map,id point,float[] value)
        
        Args:
            map (id):
            point (id):
            value (float[]):

        Returns:
            bool
        """
        pass

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

    def New(self, type, vertices, numVert, rev):
        """id polygonID = New(integer type,id[] vertices,integer numVert,integer rev)
        
        Args:
            type (int):
            vertices (id[]):
            numVert (int):
            rev (int):

        Returns:
            polygonID (id):
        """
        pass

    def NewCurveFill(self, polygons, numPols):
        """id polygonID = NewCurveFill(id[] polygons,integer numPols)
        
        Args:
            polygons (id[]):
            numPols (int):

        Returns:
            polygonID (id):
        """
        pass

    def NewProto(self, type, vertices, numVert, rev):
        """id polygonID = NewProto(integer type,id[] vertices,integer numVert,integer rev)
        
        Args:
            type (int):
            vertices (id[]):
            numVert (int):
            rev (int):

        Returns:
            polygonID (id):
        """
        pass

    def Normal(self):
        """vector normal = Normal()
        
        Returns:
            normal (tuple):
        """
        pass

    def Part(self):
        """integer part = Part()
        
        Returns:
            part (int):
        """
        pass

    def PointIndex(self, pointID):
        """integer index = PointIndex(id pointID)
        
        Args:
            pointID (id):

        Returns:
            index (int):
        """
        pass

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

    def RepresentativePosition(self):
        """vector pos = RepresentativePosition()
        
        Returns:
            pos (tuple):
        """
        pass

    def Select(self, polygon):
        """Select(id polygon)
        
        Args:
            polygon (id):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetFirstIsControlEndpoint(self, state):
        """SetFirstIsControlEndpoint(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def SetLastIsControlEndpoint(self, state):
        """SetLastIsControlEndpoint(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def SetMapValue(self, point, map, value):
        """SetMapValue(id point,id map,float[] value)
        
        Args:
            point (id):
            map (id):
            value (float[]):

        Returns:
            None
        """
        pass

    def SetMarks(self, set):
        """SetMarks(integer set)
        
        Args:
            set (int):

        Returns:
            None
        """
        pass

    def SetVertexList(self, vertices, numVert, rev):
        """SetVertexList(id[] vertices,integer numVert,integer rev)
        
        Args:
            vertices (id[]):
            numVert (int):
            rev (int):

        Returns:
            None
        """
        pass

    def SharedEdge(self, polygonID):
        """id edgeID = SharedEdge(id polygonID)
        
        Args:
            polygonID (id):

        Returns:
            edgeID (id):
        """
        pass

    def Spawn(self):
        """Polygon object = Spawn()
        
        Returns:
            object (Polygon):
        """
        pass

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

    def Symmetry(self):
        """id polygonID = Symmetry()
        
        Returns:
            polygonID (id):
        """
        pass

    def TestMarks(self, mode):
        """boolean = TestMarks(integer mode)
        
        Args:
            mode (int):

        Returns:
            bool
        """
        pass

    def TriangleByIndex(self, index):
        """(id point0,id point1,id point2) = TriangleByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (id point0,id point1,id point2)
        """
        pass

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

    def UVLookup(self, vMapName, uv):
        """(vector surfacePosition,vector surfaceNormal,vector surfaceDPDU,vector surfaceDPDV) = UVLookup(string vMapName,vector uv)
        
        Args:
            vMapName (str):
            uv (tuple):

        Returns:
            (vector surfacePosition,vector surfaceNormal,vector surfaceDPDU,vector surfaceDPDV)
        """
        pass

    def UVPart(self, map):
        """integer part = UVPart(id map)
        
        Args:
            map (id):

        Returns:
            part (int):
        """
        pass

    def VertexByIndex(self, index):
        """id point = VertexByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            point (id):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PolygonPacketTranslation:
    """PolygonPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

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

    def Mesh(self, packet):
        """Mesh object = Mesh(pointer packet)
        
        Args:
            packet (int):

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

    def Packet(self, polygon, mesh):
        """pointer = Packet(id polygon,object mesh)
        
        Args:
            polygon (id):
            mesh (lxu.object.Mesh):

        Returns:
            int
        """
        pass

    def Polygon(self, packet):
        """id polygon = Polygon(pointer packet)
        
        Args:
            packet (int):

        Returns:
            polygon (id):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PolygonSlice:
    """PolygonSlice"""
    def __init__(self, unknown=None):
        pass

    def ByLine(self, pos0, pos1):
        """ByLine(vector pos0,vector pos1)
        
        Args:
            pos0 (tuple):
            pos1 (tuple):

        Returns:
            None
        """
        pass

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

    def SetAxis(self, axis):
        """SetAxis(integer axis)
        
        Args:
            axis (int):

        Returns:
            None
        """
        pass

    def SetAxisByVector(self, axis):
        """SetAxisByVector(vector axis)
        
        Args:
            axis (tuple):

        Returns:
            None
        """
        pass

    def Start(self, meshObj, pol, setAxis):
        """Start(object meshObj,id pol,integer setAxis)
        
        Args:
            meshObj (meshObj):
            pol (id):
            setAxis (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PoseItem:
    """PoseItem"""
    def __init__(self, unknown=None):
        pass

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

    def GetFloat(self, item, channelIndex):
        """float value = GetFloat(object item,integer channelIndex)
        
        Args:
            item (lxu.object.Item):
            channelIndex (int):

        Returns:
            value (float):
        """
        pass

    def GetInt(self, item, channelIndex):
        """integer value = GetInt(object item,integer channelIndex)
        
        Args:
            item (lxu.object.Item):
            channelIndex (int):

        Returns:
            value (int):
        """
        pass

    def SetFloat(self, item, channelIndex, value):
        """SetFloat(object item,integer channelIndex,float value)
        
        Args:
            item (lxu.object.Item):
            channelIndex (int):
            value (float):

        Returns:
            None
        """
        pass

    def SetInt(self, item, channelIndex, value):
        """SetInt(object item,integer channelIndex,integer value)
        
        Args:
            item (lxu.object.Item):
            channelIndex (int):
            value (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PresetBrowserSource:
    """PresetBrowserSource"""
    def __init__(self, unknown=None):
        pass

    def ViewportHash(self):
        """string = ViewportHash()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PresetDo:
    """PresetDo"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PresetLoaderTarget:
    """PresetLoaderTarget"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            category (str):
        """
        pass

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

    def ServerName(self):
        """string = ServerName()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PresetMetrics:
    """PresetMetrics"""
    def __init__(self, unknown=None):
        pass

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

    def Markup(self):
        """Attributes object = Markup()
        
        Returns:
            object (Attributes):
        """
        pass

    def Metadata(self):
        """Attributes object = Metadata()
        
        Returns:
            object (Attributes):
        """
        pass

    def ThumbnailIdealSize(self):
        """(integer idealW,integer idealH) = ThumbnailIdealSize()
        
        Returns:
            (integer idealW,integer idealH)
        """
        pass

    def ThumbnailImage(self):
        """Image object = ThumbnailImage()
        
        Returns:
            object (lx.object.Image):
        """
        pass

    def ThumbnailResource(self):
        """string resourceName = ThumbnailResource()
        
        Returns:
            resourceName (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PresetPathPacketTranslation:
    """PresetPathPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Identifier(self, packet):
        """string identifier = Identifier(pointer packet)
        
        Args:
            packet (int):

        Returns:
            identifier (str):
        """
        pass

    def Packet(self, path, identifier):
        """pointer = Packet(string path,string identifier)
        
        Args:
            path (str):
            identifier (str):

        Returns:
            int
        """
        pass

    def Path(self, packet):
        """string path = Path(pointer packet)
        
        Args:
            packet (int):

        Returns:
            path (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PresetType:
    """PresetType"""
    def __init__(self, unknown=None):
        pass

    def Apply(self, path, destination):
        """Apply(string path,object destination)
        
        Args:
            path (str):
            destination (lxu.object.Item):

        Returns:
            None
        """
        pass

    def BaseAspect(self):
        """float aspect = BaseAspect()
        
        Returns:
            aspect (float):
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def DoCommandFlags(self, path):
        """integer flags = DoCommandFlags(string path)
        
        Args:
            path (str):

        Returns:
            flags (int):
        """
        pass

    def GenericThumbnailResource(self, path):
        """string resourceName = GenericThumbnailResource(string path)
        
        Args:
            path (str):

        Returns:
            resourceName (str):
        """
        pass

    def Metrics(self, path, flags, w, h, prevMetrics):
        """PresetMetrics object = Metrics(string path,integer flags,integer w,integer h,object prevMetrics)
        
        Args:
            path (str):
            flags (int):
            w (int):
            h (int):
            prevMetrics (prevMetrics):

        Returns:
            object (PresetMetrics):
        """
        pass

    def Recognize(self, path):
        """string category = Recognize(string path)
        
        Args:
            path (str):

        Returns:
            category (str):
        """
        pass

    def StoreMarkup(self, path, attr):
        """StoreMarkup(string path,object attr)
        
        Args:
            path (str):
            attr (attr):

        Returns:
            None
        """
        pass

    def StoreThumbnail(self, path, image):
        """StoreThumbnail(string path,object image)
        
        Args:
            path (str):
            image (lx.object.Image):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Preview:
    """Preview"""
    def __init__(self, unknown=None):
        pass

    def GetBuffer(self):
        """Image object = GetBuffer()
        
        Returns:
            object (lx.object.Image):
        """
        pass

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

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

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

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

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

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

    def SetAlpha(self, enable):
        """SetAlpha(integer enable)
        
        Args:
            enable (int):

        Returns:
            None
        """
        pass

    def SetCameraOverrideApertureX(self, apertureX):
        """SetCameraOverrideApertureX(float apertureX)
        
        Args:
            apertureX (float):

        Returns:
            None
        """
        pass

    def SetCameraOverrideApertureY(self, apertureY):
        """SetCameraOverrideApertureY(float apertureY)
        
        Args:
            apertureY (float):

        Returns:
            None
        """
        pass

    def SetCameraOverrideFocalLength(self, focalLength):
        """SetCameraOverrideFocalLength(float focalLength)
        
        Args:
            focalLength (float):

        Returns:
            None
        """
        pass

    def SetCameraOverrideProjectionType(self, projectionType):
        """SetCameraOverrideProjectionType(integer projectionType)
        
        Args:
            projectionType (int):

        Returns:
            None
        """
        pass

    def SetCameraOverrideTransform(self, transform):
        """SetCameraOverrideTransform(matrix transform)
        
        Args:
            transform (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def SetMotionBlur(self, enable):
        """SetMotionBlur(integer enable)
        
        Args:
            enable (int):

        Returns:
            None
        """
        pass

    def SetNotifier(self, notifier):
        """SetNotifier(object notifier)
        
        Args:
            notifier (lx.object.Notifier):

        Returns:
            None
        """
        pass

    def SetQuality(self, quality, samples):
        """SetQuality(integer quality,integer samples)
        
        Args:
            quality (int):
            samples (int):

        Returns:
            None
        """
        pass

    def SetRenderAllOutputs(self, enable):
        """SetRenderAllOutputs(integer enable)
        
        Args:
            enable (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SetRes(self, width, height):
        """SetRes(integer width,integer height)
        
        Args:
            width (int):
            height (int):

        Returns:
            None
        """
        pass

    def SetStereo(self, enable, eye):
        """SetStereo(integer enable,integer eye)
        
        Args:
            enable (int):
            eye (int):

        Returns:
            None
        """
        pass

    def SetUseAllThreads(self, enable):
        """SetUseAllThreads(integer enable)
        
        Args:
            enable (int):

        Returns:
            None
        """
        pass

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

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

    def UseCameraOverride(self, useCameraOverride):
        """UseCameraOverride(integer useCameraOverride)
        
        Args:
            useCameraOverride (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class PreviewNotifier:
    """PreviewNotifier"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Profile1DPreDest:
    """Profile1DPreDest"""
    def __init__(self, unknown=None):
        pass

    def Box(self):
        """bounds box = Box()
        
        Returns:
            box (bounds):
        """
        pass

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

    def CurveTo(self, x0, y0, x1, y1, x2, y2):
        """CurveTo(float x0,float y0,float x1,float y1,float x2,float y2)
        
        Args:
            x0 (float):
            y0 (float):
            x1 (float):
            y1 (float):
            x2 (float):
            y2 (float):

        Returns:
            None
        """
        pass

    def Evaluate(self, t, flags, axis):
        """float = Evaluate(float t,integer flags,integer axis)
        
        Args:
            t (float):
            flags (int):
            axis (int):

        Returns:
            float
        """
        pass

    def LineTo(self, x, y):
        """LineTo(float x,float y)
        
        Args:
            x (float):
            y (float):

        Returns:
            None
        """
        pass

    def MoveTo(self, x, y):
        """MoveTo(float x,float y)
        
        Args:
            x (float):
            y (float):

        Returns:
            None
        """
        pass

    def PathSteps(self, tol, flags, x, y, nstep):
        """integer = PathSteps(float tol,integer flags,double[] x,double[] y,integer nstep)
        
        Args:
            tol (float):
            flags (int):
            x (double[]):
            y (double[]):
            nstep (int):

        Returns:
            int
        """
        pass

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

        Returns:
            None
        """
        pass

    def SelectByParameter(self, t):
        """SelectByParameter(float t)
        
        Args:
            t (float):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Profile2DPreDest:
    """Profile2DPreDest"""
    def __init__(self, unknown=None):
        pass

    def Box(self):
        """bounds box = Box()
        
        Returns:
            box (bounds):
        """
        pass

    def Closed(self, closed):
        """Closed(integer closed)
        
        Args:
            closed (int):

        Returns:
            None
        """
        pass

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

    def CurveTo(self, x0, y0, x1, y1, x2, y2):
        """CurveTo(float x0,float y0,float x1,float y1,float x2,float y2)
        
        Args:
            x0 (float):
            y0 (float):
            x1 (float):
            y1 (float):
            x2 (float):
            y2 (float):

        Returns:
            None
        """
        pass

    def LineTo(self, x, y):
        """LineTo(float x,float y)
        
        Args:
            x (float):
            y (float):

        Returns:
            None
        """
        pass

    def MoveTo(self, x, y):
        """MoveTo(float x,float y)
        
        Args:
            x (float):
            y (float):

        Returns:
            None
        """
        pass

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

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ProjDirOverride:
    """ProjDirOverride"""
    def __init__(self, unknown=None):
        pass

    def OverrideWith(self, originalPath):
        """string = OverrideWith(string originalPath)
        
        Args:
            originalPath (str):

        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ProxyOptions:
    """ProxyOptions"""
    def __init__(self, unknown=None):
        pass

    def AddItem(self, type, internal_name, user_name):
        """AddItem(integer type,string internal_name,string user_name)
        
        Args:
            type (int):
            internal_name (str):
            user_name (str):

        Returns:
            None
        """
        pass

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

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

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Quaternion:
    """Quaternion"""
    def __init__(self, unknown=None):
        pass

    def GetAngleAxis(self):
        """(float ang,vector axis) = GetAngleAxis()
        
        Returns:
            (float ang,vector axis)
        """
        pass

    def GetMatrix(self):
        """matrix mat3 = GetMatrix()
        
        Returns:
            mat3 (lx.object.Matrix):
        """
        pass

    def GetQuaternion(self):
        """quaternion q = GetQuaternion()
        
        Returns:
            q (quaternion):
        """
        pass

    def SetAngleAxis(self, ang, axis):
        """SetAngleAxis(float ang,vector axis)
        
        Args:
            ang (float):
            axis (tuple):

        Returns:
            None
        """
        pass

    def SetMatrix(self, mat3):
        """SetMatrix(matrix mat3)
        
        Args:
            mat3 (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def SetQuaternion(self, q):
        """SetQuaternion(quaternion q)
        
        Args:
            q (quaternion):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Raycast:
    """Raycast"""
    def __init__(self, unknown=None):
        pass

    def GetSurfaceType(self, vector):
        """integer = GetSurfaceType(object vector)
        
        Args:
            vector (tuple):

        Returns:
            int
        """
        pass

    def InternalShade(self, vector):
        """InternalShade(object vector)
        
        Args:
            vector (tuple):

        Returns:
            None
        """
        pass

    def RayPop(self, vector):
        """RayPop(object vector)
        
        Args:
            vector (tuple):

        Returns:
            None
        """
        pass

    def Raycast(self, vector, pos, dir):
        """float = Raycast(object vector,vector pos,vector dir)
        
        Args:
            vector (tuple):
            pos (tuple):
            dir (tuple):

        Returns:
            float
        """
        pass

    def Raytrace(self, vector, pos, dir, flags):
        """float = Raytrace(object vector,vector pos,vector dir,integer flags)
        
        Args:
            vector (tuple):
            pos (tuple):
            dir (tuple):
            flags (int):

        Returns:
            float
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class RaycastPacket:
    """RaycastPacket"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Raymarch:
    """Raymarch"""
    def __init__(self, unknown=None):
        pass

    def GetOpacity(self, vector, dist):
        """float opa = GetOpacity(object vector,float dist)
        
        Args:
            vector (tuple):
            dist (float):

        Returns:
            opa (float):
        """
        pass

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

        Returns:
            offset (float):
        """
        pass

    def ShaderEvaluate(self, vector, shader):
        """ShaderEvaluate(object vector,object shader)
        
        Args:
            vector (tuple):
            shader (shader):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class RenderBucket:
    """RenderBucket"""
    def __init__(self, unknown=None):
        pass

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

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

    def GetSubPixel(self):
        """(float x,float y) = GetSubPixel()
        
        Returns:
            (float x,float y)
        """
        pass

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

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

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class RenderCache:
    """RenderCache"""
    def __init__(self, unknown=None):
        pass

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

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

    def Time(self):
        """(float time,float timeOffsets) = Time()
        
        Returns:
            (float time,float timeOffsets)
        """
        pass

    def Update(self, time, force):
        """Update(float time,integer force)
        
        Args:
            time (float):
            force (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class RenderJob:
    """RenderJob"""
    def __init__(self, unknown=None):
        pass

    def ActionName(self):
        """string action = ActionName()
        
        Returns:
            action (str):
        """
        pass

    def FrameBufferRegionBackgroundSlot(self):
        """(integer slotIndex,integer passIndex) = FrameBufferRegionBackgroundSlot()
        
        Returns:
            (integer slotIndex,integer passIndex)
        """
        pass

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

    def GroupName(self):
        """string group = GroupName()
        
        Returns:
            group (str):
        """
        pass

    def Options(self):
        """integer options = Options()
        
        Returns:
            options (int):
        """
        pass

    def OutputFilename(self):
        """string filename = OutputFilename()
        
        Returns:
            filename (str):
        """
        pass

    def OutputFormat(self):
        """string format = OutputFormat()
        
        Returns:
            format (str):
        """
        pass

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

    def ProgressBegin(self, renderStats):
        """ProgressBegin(object renderStats)
        
        Args:
            renderStats (renderStats):

        Returns:
            None
        """
        pass

    def ProgressBucketBegin(self, row, col):
        """ProgressBucketBegin(integer row,integer col)
        
        Args:
            row (int):
            col (int):

        Returns:
            None
        """
        pass

    def ProgressBucketEnd(self, row, col, code):
        """ProgressBucketEnd(integer row,integer col,integer code)
        
        Args:
            row (int):
            col (int):
            code (int):

        Returns:
            None
        """
        pass

    def ProgressEnd(self, finalFrameBuffer, finalStats):
        """ProgressEnd(object finalFrameBuffer,object finalStats)
        
        Args:
            finalFrameBuffer (finalFrameBuffer):
            finalStats (finalStats):

        Returns:
            None
        """
        pass

    def ProgressFrameBegin(self, frame, w, h):
        """ProgressFrameBegin(integer frame,integer w,integer h)
        
        Args:
            frame (int):
            w (int):
            h (int):

        Returns:
            None
        """
        pass

    def ProgressFrameEnd(self, frame, stats):
        """ProgressFrameEnd(integer frame,object stats)
        
        Args:
            frame (int):
            stats (stats):

        Returns:
            None
        """
        pass

    def ProgressFramePassBegin(self, frame, renderPass, eye, pass_int):
        """ProgressFramePassBegin(integer frame,integer renderPass,integer eye,integer pass_int)
        
        Args:
            frame (int):
            renderPass (int):
            eye (int):
            pass_int (int):

        Returns:
            None
        """
        pass

    def ProgressFramePassEnd(self, frame, renderPass, eye, pass_int):
        """ProgressFramePassEnd(integer frame,integer renderPass,integer eye,integer pass_int)
        
        Args:
            frame (int):
            renderPass (int):
            eye (int):
            pass_int (int):

        Returns:
            None
        """
        pass

    def ProgressImage(self, img):
        """ProgressImage(object img)
        
        Args:
            img (img):

        Returns:
            None
        """
        pass

    def ProgressImageMetrics(self, resX, resH):
        """(integer w,integer h,float zoom,integer panX,integer panY,integer output) = ProgressImageMetrics(integer resX,integer resH)
        
        Args:
            resX (int):
            resH (int):

        Returns:
            (integer w,integer h,float zoom,integer panX,integer panY,integer output)
        """
        pass

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

    def ProgressPercentDone(self, progressScene, progressFrame, progressRenderPass):
        """ProgressPercentDone(float progressScene,float progressFrame,float progressRenderPass)
        
        Args:
            progressScene (float):
            progressFrame (float):
            progressRenderPass (float):

        Returns:
            None
        """
        pass

    def ProgressRenderPassBegin(self, frameIndex, renderPassIndex, renderPassName, eye):
        """ProgressRenderPassBegin(integer frameIndex,integer renderPassIndex,string renderPassName,integer eye)
        
        Args:
            frameIndex (int):
            renderPassIndex (int):
            renderPassName (str):
            eye (int):

        Returns:
            None
        """
        pass

    def ProgressRenderPassEnd(self, frame, renderPassIndex, renderPassName, eye, frameBuffer, stats):
        """ProgressRenderPassEnd(integer frame,integer renderPassIndex,string renderPassName,integer eye,object frameBuffer,object stats)
        
        Args:
            frame (int):
            renderPassIndex (int):
            renderPassName (str):
            eye (int):
            frameBuffer (frameBuffer):
            stats (stats):

        Returns:
            None
        """
        pass

    def ProgressString(self, infoString, userString):
        """ProgressString(string infoString,string userString)
        
        Args:
            infoString (str):
            userString (str):

        Returns:
            None
        """
        pass

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

    def RenderAs(self):
        """integer mode = RenderAs()
        
        Returns:
            mode (int):
        """
        pass

    def RenderAtTime(self):
        """float time = RenderAtTime()
        
        Returns:
            time (float):
        """
        pass

    def RenderBakeCageVMap(self):
        """string vmap = RenderBakeCageVMap()
        
        Returns:
            vmap (str):
        """
        pass

    def RenderBakeEffect(self):
        """string effect = RenderBakeEffect()
        
        Returns:
            effect (str):
        """
        pass

    def RenderBakeFromRGBA(self):
        """integer mode = RenderBakeFromRGBA()
        
        Returns:
            mode (int):
        """
        pass

    def RenderBakeImage(self):
        """Image object = RenderBakeImage()
        
        Returns:
            object (lx.object.Image):
        """
        pass

    def RenderBakeLookDistance(self):
        """float distance = RenderBakeLookDistance()
        
        Returns:
            distance (float):
        """
        pass

    def RenderBakeToRGBA(self):
        """integer mode = RenderBakeToRGBA()
        
        Returns:
            mode (int):
        """
        pass

    def RenderBakeVMap(self):
        """string vmap = RenderBakeVMap()
        
        Returns:
            vmap (str):
        """
        pass

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

    def RenderTurntableFPS(self):
        """integer fps = RenderTurntableFPS()
        
        Returns:
            fps (int):
        """
        pass

    def RenderTurntableNumFrames(self):
        """integer numFrames = RenderTurntableNumFrames()
        
        Returns:
            numFrames (int):
        """
        pass

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

        Returns:
            None
        """
        pass

    def UDIM(self):
        """integer udim = UDIM()
        
        Returns:
            udim (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class RenderProgressListener:
    """RenderProgressListener"""
    def __init__(self, unknown=None):
        pass

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

    def End(self, stats):
        """End(object stats)
        
        Args:
            stats (stats):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class RenderStats:
    """RenderStats"""
    def __init__(self, unknown=None):
        pass

    def GetFrameStats(self, frameIndex):
        """Unknown object = GetFrameStats(integer frameIndex)
        
        Args:
            frameIndex (int):

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

    def GetPassStats(self, frameIndex, passIndex):
        """Unknown object = GetPassStats(integer frameIndex,integer passIndex)
        
        Args:
            frameIndex (int):
            passIndex (int):

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

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

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

    def NumPasses(self, frameIndex):
        """integer count = NumPasses(integer frameIndex)
        
        Args:
            frameIndex (int):

        Returns:
            count (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ReplicatorEnumerator:
    """ReplicatorEnumerator"""
    def __init__(self, unknown=None):
        pass

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

    def Enumerate(self, visitor, chan, localXform):
        """Enumerate(object visitor,object chan,integer localXform)
        
        Args:
            visitor (visitor):
            chan (chan):
            localXform (int):

        Returns:
            None
        """
        pass

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

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

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

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

    def Orientation(self):
        """matrix mx = Orientation()
        
        Returns:
            mx (lx.object.Matrix):
        """
        pass

    def Position(self):
        """vector pos = Position()
        
        Returns:
            pos (tuple):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Saver:
    """Saver"""
    def __init__(self, unknown=None):
        pass

    def Save(self, source, filename, monitor):
        """Save(object source,string filename,object monitor)
        
        Args:
            source (lxu.object.Item):
            filename (str):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def Verify(self, source, message):
        """Verify(object source,object message)
        
        Args:
            source (lxu.object.Item):
            message (message):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Scene:
    """Scene"""
    def __init__(self, unknown=None):
        pass

    def AllocAssets(self):
        """SceneAssets object = AllocAssets()
        
        Returns:
            object (SceneAssets):
        """
        pass

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

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

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

    def BatchCopyBegin(self, destination):
        """BatchCopyBegin(object destination)
        
        Args:
            destination (lxu.object.Item):

        Returns:
            None
        """
        pass

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

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

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

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

    def Changed(self, changed):
        """Changed(integer changed)
        
        Args:
            changed (int):

        Returns:
            None
        """
        pass

    def Channels(self, name, time):
        """ChannelRead object = Channels(string name,float time)
        
        Args:
            name (str):
            time (float):

        Returns:
            object (ChannelRead):
        """
        pass

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

        Returns:
            None
        """
        pass

    def DeleteCollection(self, collection, closeMode):
        """DeleteCollection(object collection,integer closeMode)
        
        Args:
            collection (collection):
            closeMode (int):

        Returns:
            None
        """
        pass

    def EvalModInvalidate(self, modName):
        """EvalModInvalidate(string modName)
        
        Args:
            modName (str):

        Returns:
            None
        """
        pass

    def EvalModReset(self, modName):
        """EvalModReset(string modName)
        
        Args:
            modName (str):

        Returns:
            None
        """
        pass

    def FileFormat(self):
        """string format = FileFormat()
        
        Returns:
            format (str):
        """
        pass

    def Filename(self):
        """string filename = Filename()
        
        Returns:
            filename (str):
        """
        pass

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

        Returns:
            filename (str):
        """
        pass

    def GeneralCollection(self, typeName, arg, rootItem):
        """Unknown object = GeneralCollection(string typeName,string arg,object rootItem)
        
        Args:
            typeName (str):
            arg (str):
            rootItem (rootItem):

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

    def GeneralCollectionRaw(self, typeName, arg, rootItem):
        """Unknown object = GeneralCollectionRaw(string typeName,string arg,object rootItem)
        
        Args:
            typeName (str):
            arg (str):
            rootItem (rootItem):

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

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

        Returns:
            object (SceneGraph):
        """
        pass

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

    def GraphLookup(self, name):
        """SceneGraph object = GraphLookup(string name)
        
        Args:
            name (str):

        Returns:
            object (SceneGraph):
        """
        pass

    def HasChanged(self):
        """integer numChanges = HasChanged()
        
        Returns:
            numChanges (int):
        """
        pass

    def Import(self, path, monitor):
        """Import(string path,object monitor)
        
        Args:
            path (str):
            monitor (monitor):

        Returns:
            None
        """
        pass

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

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

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

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

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

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

    def ItemByIndexByTypes(self, types, index):
        """Item object = ItemByIndexByTypes(int[] types,integer index)
        
        Args:
            types (int[]):
            index (int):

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

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

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

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

        Returns:
            count (int):
        """
        pass

    def ItemCountByTypes(self, types):
        """integer count = ItemCountByTypes(int[] types)
        
        Args:
            types (int[]):

        Returns:
            count (int):
        """
        pass

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

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

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

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

    def ItemLookup(self, id):
        """Item object = ItemLookup(string id)
        
        Args:
            id (str):

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

    def ItemLookupIdent(self, id):
        """Item object = ItemLookupIdent(string id)
        
        Args:
            id (str):

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

    def ItemLookupImported(self, id):
        """Item object = ItemLookupImported(string id)
        
        Args:
            id (str):

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

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

        Returns:
            None
        """
        pass

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

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

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

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

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

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

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

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

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

        Returns:
            index (int):
        """
        pass

    def SetupChannels(self):
        """ChannelRead object = SetupChannels()
        
        Returns:
            object (ChannelRead):
        """
        pass

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

    def SubSceneByIndex(self, type, index):
        """Scene object = SubSceneByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            object (Scene):
        """
        pass

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

        Returns:
            count (int):
        """
        pass

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

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

    def WorkPlanePosition(self, chanRead):
        """vector pos = WorkPlanePosition(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            pos (tuple):
        """
        pass

    def WorkPlaneRotation(self, chanRead):
        """matrix m3 = WorkPlaneRotation(object chanRead)
        
        Args:
            chanRead (chanRead):

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneAssets:
    """SceneAssets"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            category (str):
        """
        pass

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

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

        Returns:
            type (str):
        """
        pass

    def GetPath(self, item, ident):
        """string = GetPath(object item,string ident)
        
        Args:
            item (lxu.object.Item):
            ident (str):

        Returns:
            str
        """
        pass

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

        Returns:
            ident (str):
        """
        pass

    def IsSequence(self, index):
        """boolean = IsSequence(integer index)
        
        Args:
            index (int):

        Returns:
            bool
        """
        pass

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

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

    def SetPath(self, item, ident, newPath):
        """SetPath(object item,string ident,string newPath)
        
        Args:
            item (lxu.object.Item):
            ident (str):
            newPath (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneContents:
    """SceneContents"""
    def __init__(self, unknown=None):
        pass

    def AddLink(self, type, internal_name, user_name):
        """AddLink(integer type,string internal_name,string user_name)
        
        Args:
            type (int):
            internal_name (str):
            user_name (str):

        Returns:
            None
        """
        pass

    def BBox(self, index):
        """bounds box = BBox(integer index)
        
        Args:
            index (int):

        Returns:
            box (bounds):
        """
        pass

    def ByInternalName(self, internal_name):
        """integer index = ByInternalName(string internal_name)
        
        Args:
            internal_name (str):

        Returns:
            index (int):
        """
        pass

    def ByUserName(self, user_name):
        """integer index = ByUserName(string user_name)
        
        Args:
            user_name (str):

        Returns:
            index (int):
        """
        pass

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

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

        Returns:
            str
        """
        pass

    def Item(self, type, internal_name, user_name):
        """Item(integer type,string internal_name,string user_name)
        
        Args:
            type (int):
            internal_name (str):
            user_name (str):

        Returns:
            None
        """
        pass

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

        Returns:
            int
        """
        pass

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

    def SetBBox(self, min_X, min_Y, min_Z, max_X, max_Y, max_Z):
        """SetBBox(float min_X,float min_Y,float min_Z,float max_X,float max_Y,float max_Z)
        
        Args:
            min_X (float):
            min_Y (float):
            min_Z (float):
            max_X (float):
            max_Y (float):
            max_Z (float):

        Returns:
            None
        """
        pass

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

        Returns:
            type (int):
        """
        pass

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

        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneEvalListener:
    """SceneEvalListener"""
    def __init__(self, unknown=None):
        pass

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

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

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneGraph:
    """SceneGraph"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

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

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

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

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

        Returns:
            None
        """
        pass

    def RootSetPos(self, item, pos):
        """RootSetPos(object item,integer pos)
        
        Args:
            item (lxu.object.Item):
            pos (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneItemListener:
    """SceneItemListener"""
    def __init__(self, unknown=None):
        pass

    def ChanLinkAdd(self, graph, itemFrom, chanFrom, itemTo, chanTo):
        """ChanLinkAdd(string graph,object itemFrom,integer chanFrom,object itemTo,integer chanTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            chanFrom (int):
            itemTo (itemTo):
            chanTo (int):

        Returns:
            None
        """
        pass

    def ChanLinkRemAfter(self, graph, itemFrom, chanFrom, itemTo, chanTo):
        """ChanLinkRemAfter(string graph,object itemFrom,integer chanFrom,object itemTo,integer chanTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            chanFrom (int):
            itemTo (itemTo):
            chanTo (int):

        Returns:
            None
        """
        pass

    def ChanLinkRemBefore(self, graph, itemFrom, chanFrom, itemTo, chanTo):
        """ChanLinkRemBefore(string graph,object itemFrom,integer chanFrom,object itemTo,integer chanTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            chanFrom (int):
            itemTo (itemTo):
            chanTo (int):

        Returns:
            None
        """
        pass

    def ChanLinkSet(self, graph, itemFrom, chanFrom, itemTo, chanTo):
        """ChanLinkSet(string graph,object itemFrom,integer chanFrom,object itemTo,integer chanTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            chanFrom (int):
            itemTo (itemTo):
            chanTo (int):

        Returns:
            None
        """
        pass

    def ChannelValue(self, action, item, index):
        """ChannelValue(string action,object item,integer index)
        
        Args:
            action (str):
            item (lxu.object.Item):
            index (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def LinkAdd(self, graph, itemFrom, itemTo):
        """LinkAdd(string graph,object itemFrom,object itemTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            itemTo (itemTo):

        Returns:
            None
        """
        pass

    def LinkRemAfter(self, graph, itemFrom, itemTo):
        """LinkRemAfter(string graph,object itemFrom,object itemTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            itemTo (itemTo):

        Returns:
            None
        """
        pass

    def LinkRemBefore(self, graph, itemFrom, itemTo):
        """LinkRemBefore(string graph,object itemFrom,object itemTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            itemTo (itemTo):

        Returns:
            None
        """
        pass

    def LinkSet(self, graph, itemFrom, itemTo):
        """LinkSet(string graph,object itemFrom,object itemTo)
        
        Args:
            graph (str):
            itemFrom (itemFrom):
            itemTo (itemTo):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def SceneFilename(self, scene, filename):
        """SceneFilename(object scene,string filename)
        
        Args:
            scene (scene):
            filename (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneItemPreDest:
    """SceneItemPreDest"""
    def __init__(self, unknown=None):
        pass

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

    def Item(self):
        """(integer mode,Item object) = Item()
        
        Returns:
            (integer mode,Item object)
        """
        pass

    def Orientation(self):
        """matrix xfrm = Orientation()
        
        Returns:
            xfrm (lx.object.Matrix):
        """
        pass

    def Position(self):
        """vector pos = Position()
        
        Returns:
            pos (tuple):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneLoaderTarget:
    """SceneLoaderTarget"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ScenePacketTranslation:
    """ScenePacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Packet(self, scene):
        """pointer = Packet(object scene)
        
        Args:
            scene (scene):

        Returns:
            int
        """
        pass

    def Scene(self, packet):
        """Scene object = Scene(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (Scene):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SceneSubset:
    """SceneSubset"""
    def __init__(self, unknown=None):
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SchemaDest:
    """SchemaDest"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

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

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

    def Position(self):
        """vector pos = Position()
        
        Returns:
            pos (tuple):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SchematicConnection:
    """SchematicConnection"""
    def __init__(self, unknown=None):
        pass

    def AllowConnect(self, from_obj, to_obj):
        """boolean = AllowConnect(object from_obj,object to_obj)
        
        Args:
            from_obj (from_obj):
            to_obj (to_obj):

        Returns:
            bool
        """
        pass

    def AllowConnectType(self, to_obj, type):
        """boolean = AllowConnectType(object to_obj,integer type)
        
        Args:
            to_obj (to_obj):
            type (int):

        Returns:
            bool
        """
        pass

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

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

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

    def ChannelAllowConnect(self, from_obj, fromIndex, to_obj, toIndex):
        """boolean = ChannelAllowConnect(object from_obj,integer fromIndex,object to_obj,integer toIndex)
        
        Args:
            from_obj (from_obj):
            fromIndex (int):
            to_obj (to_obj):
            toIndex (int):

        Returns:
            bool
        """
        pass

    def ChannelByIndex(self, xItem, fromIndex, index):
        """(Item object,integer toIndex) = ChannelByIndex(object xItem,integer fromIndex,integer index)
        
        Args:
            xItem (xItem):
            fromIndex (int):
            index (int):

        Returns:
            (Item object,integer toIndex)
        """
        pass

    def ChannelConnect(self, from_obj, fromIndex, to_obj, toIndex):
        """ChannelConnect(object from_obj,integer fromIndex,object to_obj,integer toIndex)
        
        Args:
            from_obj (from_obj):
            fromIndex (int):
            to_obj (to_obj):
            toIndex (int):

        Returns:
            None
        """
        pass

    def ChannelCount(self, xItem, fromIndex):
        """integer count = ChannelCount(object xItem,integer fromIndex)
        
        Args:
            xItem (xItem):
            fromIndex (int):

        Returns:
            count (int):
        """
        pass

    def ChannelDisconnect(self, from_obj, fromIndex, to_obj, toIndex):
        """ChannelDisconnect(object from_obj,integer fromIndex,object to_obj,integer toIndex)
        
        Args:
            from_obj (from_obj):
            fromIndex (int):
            to_obj (to_obj):
            toIndex (int):

        Returns:
            None
        """
        pass

    def ChannelIOType(self):
        """integer ioType = ChannelIOType()
        
        Returns:
            ioType (int):
        """
        pass

    def Connect(self, from_obj, to_obj, toIndex):
        """Connect(object from_obj,object to_obj,integer toIndex)
        
        Args:
            from_obj (from_obj):
            to_obj (to_obj):
            toIndex (int):

        Returns:
            None
        """
        pass

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

        Returns:
            count (int):
        """
        pass

    def Disconnect(self, from_obj, to_obj):
        """Disconnect(object from_obj,object to_obj)
        
        Args:
            from_obj (from_obj):
            to_obj (to_obj):

        Returns:
            None
        """
        pass

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

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

        Returns:
            flags (int):
        """
        pass

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

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

        Returns:
            flags (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SchematicGroup:
    """SchematicGroup"""
    def __init__(self, unknown=None):
        pass

    def AddItem(self, item):
        """SchematicNode object = AddItem(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            object (SchematicNode):
        """
        pass

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

    def InputNode(self):
        """SchematicNode object = InputNode()
        
        Returns:
            object (SchematicNode):
        """
        pass

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

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

        Returns:
            object (SchematicNode):
        """
        pass

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

    def OutputNode(self):
        """SchematicNode object = OutputNode()
        
        Returns:
            object (SchematicNode):
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SchematicNode:
    """SchematicNode"""
    def __init__(self, unknown=None):
        pass

    def AbsoluteSize(self):
        """(float width,float height) = AbsoluteSize()
        
        Returns:
            (float width,float height)
        """
        pass

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

        Returns:
            None
        """
        pass

    def ChannelByIndex(self, index, type):
        """SchematicNodeChannel object = ChannelByIndex(integer index,integer type)
        
        Args:
            index (int):
            type (int):

        Returns:
            object (SchematicNodeChannel):
        """
        pass

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

    def ConnectionByIndex(self, index, type):
        """SchematicNodeConnection object = ConnectionByIndex(integer index,integer type)
        
        Args:
            index (int):
            type (int):

        Returns:
            object (SchematicNodeConnection):
        """
        pass

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

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

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

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

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

    def Position(self):
        """(float x,float y) = Position()
        
        Returns:
            (float x,float y)
        """
        pass

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

        Returns:
            None
        """
        pass

    def RootNode(self):
        """SchematicNode object = RootNode()
        
        Returns:
            object (SchematicNode):
        """
        pass

    def SetPosition(self, x, y):
        """SetPosition(float x,float y)
        
        Args:
            x (float):
            y (float):

        Returns:
            None
        """
        pass

    def Size(self):
        """(float width,float height) = Size()
        
        Returns:
            (float width,float height)
        """
        pass

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

        Returns:
            object (SchematicNode):
        """
        pass

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SchematicNodeChannel:
    """SchematicNodeChannel"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            object (SchematicNodeChannel):
        """
        pass

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

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

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

    def Node(self):
        """SchematicNode object = Node()
        
        Returns:
            object (SchematicNode):
        """
        pass

    def Position(self):
        """(float x,float y) = Position()
        
        Returns:
            (float x,float y)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SchematicNodeConnection:
    """SchematicNodeConnection"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            object (SchematicNodeConnection):
        """
        pass

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

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

    def Node(self):
        """SchematicNode object = Node()
        
        Returns:
            object (SchematicNode):
        """
        pass

    def Position(self, index):
        """(float x,float y) = Position(integer index)
        
        Args:
            index (int):

        Returns:
            (float x,float y)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Script:
    """Script"""
    def __init__(self, unknown=None):
        pass

    def Desc(self):
        """string desc = Desc()
        
        Returns:
            desc (str):
        """
        pass

    def GetBuffer(self):
        """(string buffer,integer bufferLength) = GetBuffer()
        
        Returns:
            (string buffer,integer bufferLength)
        """
        pass

    def Hash(self):
        """string hash = Hash()
        
        Returns:
            hash (str):
        """
        pass

    def HelpKey(self, args):
        """string key = HelpKey(string args)
        
        Args:
            args (str):

        Returns:
            key (str):
        """
        pass

    def Icon(self):
        """string icon = Icon()
        
        Returns:
            icon (str):
        """
        pass

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

    def SetBuffer(self, buffer, bufferLength):
        """SetBuffer(string buffer,integer bufferLength)
        
        Args:
            buffer (str):
            bufferLength (int):

        Returns:
            None
        """
        pass

    def SetDesc(self, desc):
        """SetDesc(string desc)
        
        Args:
            desc (str):

        Returns:
            None
        """
        pass

    def SetUserName(self, userName):
        """SetUserName(string userName)
        
        Args:
            userName (str):

        Returns:
            None
        """
        pass

    def UserName(self):
        """string userName = UserName()
        
        Returns:
            userName (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ScriptLineEvent:
    """ScriptLineEvent"""
    def __init__(self, unknown=None):
        pass

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ScriptManager:
    """ScriptManager"""
    def __init__(self, unknown=None):
        pass

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

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

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

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

    def Lookup(self, hash, write, tryAsUserName):
        """Unknown object = Lookup(string hash,integer write,integer tryAsUserName)
        
        Args:
            hash (str):
            write (int):
            tryAsUserName (int):

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

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

    def New(self, name):
        """Unknown object = New(string name)
        
        Args:
            name (str):

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

    def ReadWrite(self, hash, index):
        """ReadWrite(string hash,integer index)
        
        Args:
            hash (str):
            index (int):

        Returns:
            None
        """
        pass

    def Remove(self, script):
        """Remove(object script)
        
        Args:
            script (script):

        Returns:
            None
        """
        pass

    def Run(self, script, execFlags, args, msg):
        """Run(object script,integer execFlags,string args,object msg)
        
        Args:
            script (script):
            execFlags (int):
            args (str):
            msg (msg):

        Returns:
            None
        """
        pass

    def Validate(self, script, msg):
        """Validate(object script,object msg)
        
        Args:
            script (script):
            msg (msg):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ScriptQuery:
    """ScriptQuery"""
    def __init__(self, unknown=None):
        pass

    def Query(self, attribute, query):
        """Query(string attribute,object query)
        
        Args:
            attribute (str):
            query (query):

        Returns:
            None
        """
        pass

    def Select(self, attribute, which):
        """Select(string attribute,string which)
        
        Args:
            attribute (str):
            which (str):

        Returns:
            None
        """
        pass

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

        Returns:
            type (int):
        """
        pass

    def TypeName(self, attribute):
        """string type = TypeName(string attribute)
        
        Args:
            attribute (str):

        Returns:
            type (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SelectionListener:
    """SelectionListener"""
    def __init__(self, unknown=None):
        pass

    def Add(self, type, subtType):
        """Add(integer type,integer subtType)
        
        Args:
            type (int):
            subtType (int):

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

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

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SelectionOperation:
    """SelectionOperation"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self, type, state):
        """Evaluate(integer type,object state)
        
        Args:
            type (int):
            state (state):

        Returns:
            None
        """
        pass

    def SetMesh(self, mesh):
        """SetMesh(object mesh)
        
        Args:
            mesh (lxu.object.Mesh):

        Returns:
            None
        """
        pass

    def SetTransform(self):
        """matrix xfrm = SetTransform()
        
        Returns:
            xfrm (lx.object.Matrix):
        """
        pass

    def TestEdge(self, edge):
        """boolean = TestEdge(id edge)
        
        Args:
            edge (id):

        Returns:
            bool
        """
        pass

    def TestPoint(self, point):
        """boolean = TestPoint(id point)
        
        Args:
            point (id):

        Returns:
            bool
        """
        pass

    def TestPolygon(self, polygon):
        """boolean = TestPolygon(id polygon)
        
        Args:
            polygon (id):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SelectionState:
    """SelectionState"""
    def __init__(self, unknown=None):
        pass

    def SetEdge(self, edge, state):
        """SetEdge(id edge,integer state)
        
        Args:
            edge (id):
            state (int):

        Returns:
            None
        """
        pass

    def SetPoint(self, point, state):
        """SetPoint(id point,integer state)
        
        Args:
            point (id):
            state (int):

        Returns:
            None
        """
        pass

    def SetPolygon(self, polygon, state):
        """SetPolygon(id polygon,integer state)
        
        Args:
            polygon (id):
            state (int):

        Returns:
            None
        """
        pass

    def TestEdge(self, edge):
        """boolean = TestEdge(id edge)
        
        Args:
            edge (id):

        Returns:
            bool
        """
        pass

    def TestPoint(self, point):
        """boolean = TestPoint(id point)
        
        Args:
            point (id):

        Returns:
            bool
        """
        pass

    def TestPolygon(self, polygon):
        """boolean = TestPolygon(id polygon)
        
        Args:
            polygon (id):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SelectionType:
    """SelectionType"""
    def __init__(self, unknown=None):
        pass

    def Compare(self, pkey, pelt):
        """integer = Compare(pointer pkey,pointer pelt)
        
        Args:
            pkey (int):
            pelt (int):

        Returns:
            int
        """
        pass

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

    def MessageTable(self):
        """string = MessageTable()
        
        Returns:
            str
        """
        pass

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

    def SubType(self, pkt):
        """integer = SubType(pointer pkt)
        
        Args:
            pkt (int):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SessionListener:
    """SessionListener"""
    def __init__(self, unknown=None):
        pass

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

    def CheckQuitUI(self, quitWasAborted):
        """boolean = CheckQuitUI(integer quitWasAborted)
        
        Args:
            quitWasAborted (int):

        Returns:
            bool
        """
        pass

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

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

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

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

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

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Shader:
    """Shader"""
    def __init__(self, unknown=None):
        pass

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

        Returns:
            None
        """
        pass

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

    def Spawn(self):
        """Shader object = Spawn()
        
        Returns:
            object (Shader):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ShaderDest:
    """ShaderDest"""
    def __init__(self, unknown=None):
        pass

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

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

    def Type(self):
        """integer = Type()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ShaderPreDest:
    """ShaderPreDest"""
    def __init__(self, unknown=None):
        pass

    def ContainerItem(self):
        """Item object = ContainerItem()
        
        Returns:
            object (lxu.object.Item):
        """
        pass

    def GetTag(self, type):
        """string tag = GetTag(integer type)
        
        Args:
            type (int):

        Returns:
            tag (str):
        """
        pass

    def HitItem(self):
        """Item object = HitItem()
        
        Returns:
            object (lxu.object.Item):
        """
        pass

    def Item(self):
        """(integer mode,Item object) = Item()
        
        Returns:
            (integer mode,Item object)
        """
        pass

    def Mode(self):
        """integer mode = Mode()
        
        Returns:
            mode (int):
        """
        pass

    def Scene(self):
        """Scene object = Scene()
        
        Returns:
            object (Scene):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ShaderSlice:
    """ShaderSlice"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self, vecstack):
        """Evaluate(object vecstack)
        
        Args:
            vecstack (vecstack):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ShapeDraw:
    """ShapeDraw"""
    def __init__(self, unknown=None):
        pass

    def Arc(self, col, alpha, pos, rad, start, end, axis, flags):
        """Arc(vector col,float alpha,vector pos,float rad,float start,float end,integer axis,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            rad (float):
            start (float):
            end (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Arrow(self, col, pos, size, axis, flags):
        """Arrow(vector col,vector pos,float size,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            size (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Axis(self, col, pos, size, flags):
        """Axis(vector col,vector pos,vector size,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            size (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def BBox(self, col, size, flags):
        """BBox(vector col,float size,integer flags)
        
        Args:
            col (tuple):
            size (float):
            flags (int):

        Returns:
            None
        """
        pass

    def Bone(self, col, rlen, active):
        """Bone(vector col,float rlen,integer active)
        
        Args:
            col (tuple):
            rlen (float):
            active (int):

        Returns:
            None
        """
        pass

    def BoxShape(self, colW, colF, pos, size, flags):
        """BoxShape(vector colW,vector colF,vector pos,vector size,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            size (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def CSeg(self, cen, offset, screen, col, flags):
        """CSeg(vector cen,vector offset,float screen,vector col,integer flags)
        
        Args:
            cen (tuple):
            offset (tuple):
            screen (float):
            col (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def Circle(self, col, alpha, pos, rad, axis, flags):
        """Circle(vector col,float alpha,vector pos,float rad,integer axis,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            rad (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def CircleShape(self, colW, colF, pos, radius, axis, flags):
        """CircleShape(vector colW,vector colF,vector pos,float radius,integer axis,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            radius (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Cone(self, col, pos, rad, height, axis, flags):
        """Cone(vector col,vector pos,float rad,float height,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            rad (float):
            height (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def ConeShape(self, colW, colF, pos, radius, height, axis, flags):
        """ConeShape(vector colW,vector colF,vector pos,float radius,float height,integer axis,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            radius (float):
            height (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Cross(self, col, pos, rad, flags):
        """Cross(vector col,vector pos,vector rad,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            rad (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def CrossHair(self, col, alpha, pos, flags):
        """CrossHair(vector col,float alpha,vector pos,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def Cube(self, col, pos, size, flags):
        """Cube(vector col,vector pos,vector size,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            size (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def CubeFill(self, col, alpha, pos, size, flags):
        """CubeFill(vector col,float alpha,vector pos,vector size,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            size (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def Cylinder(self, col, pos, rad, height, axis, flags):
        """Cylinder(vector col,vector pos,float rad,float height,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            rad (float):
            height (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def CylinderShape(self, colW, colF, pos, radius, height, axis, flags):
        """CylinderShape(vector colW,vector colF,vector pos,float radius,float height,integer axis,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            radius (float):
            height (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Dimension(self, col, A, B, format, top, flags):
        """Dimension(vector col,vector A,vector B,string format,integer top,integer flags)
        
        Args:
            col (tuple):
            A (tuple):
            B (tuple):
            format (str):
            top (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Distance(self, col, pos, dist, axis, flags):
        """Distance(vector col,vector pos,float dist,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            dist (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Ellipse(self, col, alpha, pos, rad, axis, flags):
        """Ellipse(vector col,float alpha,vector pos,vector rad,integer axis,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            rad (tuple):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Ellipsoid(self, col, alpha, pos, rad, flags):
        """Ellipsoid(vector col,float alpha,vector pos,vector rad,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            rad (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def Grid(self, col, pos, siz, divX, divY, divZ, axis, flags):
        """Grid(vector col,vector pos,vector siz,integer divX,integer divY,integer divZ,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            siz (tuple):
            divX (int):
            divY (int):
            divZ (int):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Line(self, v0, v1, col, alpha, flags):
        """Line(vector v0,vector v1,vector col,float alpha,integer flags)
        
        Args:
            v0 (tuple):
            v1 (tuple):
            col (tuple):
            alpha (float):
            flags (int):

        Returns:
            None
        """
        pass

    def Link(self, col, posS, posE, solid, flags):
        """Link(vector col,vector posS,vector posE,integer solid,integer flags)
        
        Args:
            col (tuple):
            posS (tuple):
            posE (tuple):
            solid (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Pill(self, col, alpha, pos, width, height, rad, axis, flags):
        """Pill(vector col,float alpha,vector pos,float width,float height,float rad,integer axis,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            width (float):
            height (float):
            rad (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Plane(self, col, pos, size, axis, flags):
        """Plane(vector col,vector pos,vector size,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            size (tuple):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def PlaneIndicator(self, col, alpha, pos, rad, axis, flags):
        """PlaneIndicator(vector col,float alpha,vector pos,float rad,integer axis,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            rad (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def PlaneShape(self, colW, colF, pos, size, axis, flags):
        """PlaneShape(vector colW,vector colF,vector pos,vector size,integer axis,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            size (tuple):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def PreciseHandle(self, col, alpha, pos, size, flags):
        """PreciseHandle(vector col,float alpha,vector pos,vector size,integer flags)
        
        Args:
            col (tuple):
            alpha (float):
            pos (tuple):
            size (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def Pyramid(self, col, pos, size, axis, flags):
        """Pyramid(vector col,vector pos,vector size,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            size (tuple):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def PyramidShape(self, colW, colF, pos, size, axis, flags):
        """PyramidShape(vector colW,vector colF,vector pos,vector size,integer axis,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            size (tuple):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def RadialMap(self, image, col, cen, size, sel, flags):
        """RadialMap(object image,vector col,vector cen,float size,integer sel,integer flags)
        
        Args:
            image (lx.object.Image):
            col (tuple):
            cen (tuple):
            size (float):
            sel (int):
            flags (int):

        Returns:
            None
        """
        pass

    def RadialRays(self, image, col, cen, size, sel, flags):
        """RadialRays(object image,vector col,vector cen,float size,integer sel,integer flags)
        
        Args:
            image (lx.object.Image):
            col (tuple):
            cen (tuple):
            size (float):
            sel (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Rhombus(self, col, pos, size, axis, flags):
        """Rhombus(vector col,vector pos,vector size,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            size (tuple):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def RhombusShape(self, colW, colF, pos, size, axis, flags):
        """RhombusShape(vector colW,vector colF,vector pos,vector size,integer axis,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            size (tuple):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Ruler(self, col, pos, xfrm, len, axis, flags):
        """Ruler(vector col,vector pos,matrix xfrm,float len,integer axis,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            xfrm (lx.object.Matrix):
            len (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def SphereShape(self, colW, colF, pos, radius, axis, flags):
        """SphereShape(vector colW,vector colF,vector pos,float radius,integer axis,integer flags)
        
        Args:
            colW (tuple):
            colF (tuple):
            pos (tuple):
            radius (float):
            axis (int):
            flags (int):

        Returns:
            None
        """
        pass

    def Star(self, col, pos, rad, flags):
        """Star(vector col,vector pos,vector rad,integer flags)
        
        Args:
            col (tuple):
            pos (tuple):
            rad (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SharedWork:
    """SharedWork"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self):
        """Evaluate()
        
        Returns:
            None
        """
        pass

    def Share(self, other, split):
        """Share(object other,integer split)
        
        Args:
            other (other):
            split (int):

        Returns:
            None
        """
        pass

    def Spawn(self):
        """SharedWork object = Spawn()
        
        Returns:
            object (SharedWork):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SimulationListener:
    """SimulationListener"""
    def __init__(self, unknown=None):
        pass

    def End(self):
        """End()
        
        Returns:
            None
        """
        pass

    def Invalidate(self):
        """Invalidate()
        
        Returns:
            None
        """
        pass

    def Start(self, channels):
        """Start(object channels)
        
        Args:
            channels (channels):

        Returns:
            None
        """
        pass

    def Time(self, time):
        """Time(float time)
        
        Args:
            time (float):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SimulationModifier:
    """SimulationModifier"""
    def __init__(self, unknown=None):
        pass

    def Bake(self, time):
        """Bake(float time)
        
        Args:
            time (float):

        Returns:
            None
        """
        pass

    def Cleanup(self):
        """Cleanup()
        
        Returns:
            None
        """
        pass

    def Enabled(self, chanRead):
        """boolean = Enabled(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            bool
        """
        pass

    def Initialize(self, time, sample):
        """Initialize(float time,float sample)
        
        Args:
            time (float):
            sample (float):

        Returns:
            None
        """
        pass

    def Step(self, dt):
        """Step(float dt)
        
        Args:
            dt (float):

        Returns:
            None
        """
        pass

    def StepSize(self):
        """float stepSize = StepSize()
        
        Returns:
            stepSize (float):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SolidDrill:
    """SolidDrill"""
    def __init__(self, unknown=None):
        pass

    def AddMesh(self, meshObj, xfrm):
        """AddMesh(object meshObj,matrix xfrm)
        
        Args:
            meshObj (meshObj):
            xfrm (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def Clear(self):
        """Clear()
        
        Returns:
            None
        """
        pass

    def Execute(self, meshObj, xfrm, pick, mode, sten, monitor):
        """Execute(object meshObj,matrix xfrm,integer pick,integer mode,string sten,object monitor)
        
        Args:
            meshObj (meshObj):
            xfrm (lx.object.Matrix):
            pick (int):
            mode (int):
            sten (str):
            monitor (monitor):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class StackFilter:
    """StackFilter"""
    def __init__(self, unknown=None):
        pass

    def Compare(self, other):
        """integer = Compare(object other)
        
        Args:
            other (other):

        Returns:
            int
        """
        pass

    def Convert(self, other):
        """Convert(object other)
        
        Args:
            other (other):

        Returns:
            None
        """
        pass

    def Identifier(self):
        """string identifier = Identifier()
        
        Returns:
            identifier (str):
        """
        pass

    def Type(self):
        """string = Type()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class StreamIO:
    """StreamIO"""
    def __init__(self, unknown=None):
        pass

    def Read(self, stream):
        """Read(object stream)
        
        Args:
            stream (stream):

        Returns:
            None
        """
        pass

    def Write(self, stream):
        """Write(object stream)
        
        Args:
            stream (stream):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class StringConversion:
    """StringConversion"""
    def __init__(self, unknown=None):
        pass

    def Decode(self, buf):
        """Decode(string buf)
        
        Args:
            buf (str):

        Returns:
            None
        """
        pass

    def Encode(self):
        """string = Encode()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class StringConversionNice:
    """StringConversionNice"""
    def __init__(self, unknown=None):
        pass

    def Decode(self, buf):
        """Decode(string buf)
        
        Args:
            buf (str):

        Returns:
            None
        """
        pass

    def Encode(self):
        """string = Encode()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class StringTag:
    """StringTag"""
    def __init__(self, unknown=None):
        pass

    def ByIndex(self, index):
        """(integer type,string tag) = ByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (integer type,string tag)
        """
        pass

    def Count(self):
        """integer count = Count()
        
        Returns:
            count (int):
        """
        pass

    def Get(self, type):
        """string tag = Get(integer type)
        
        Args:
            type (int):

        Returns:
            tag (str):
        """
        pass

    def Set(self, type, tag):
        """Set(integer type,string tag)
        
        Args:
            type (int):
            tag (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class StrokeDraw:
    """StrokeDraw"""
    def __init__(self, unknown=None):
        pass

    def Begin(self, type, color, alpha):
        """Begin(integer type,vector color,float alpha)
        
        Args:
            type (int):
            color (tuple):
            alpha (float):

        Returns:
            None
        """
        pass

    def BeginI(self, texture, type, color, alpha):
        """BeginI(object texture,integer type,vector color,float alpha)
        
        Args:
            texture (texture):
            type (int):
            color (tuple):
            alpha (float):

        Returns:
            None
        """
        pass

    def BeginPoints(self, size, color, alpha):
        """BeginPoints(float size,vector color,float alpha)
        
        Args:
            size (float):
            color (tuple):
            alpha (float):

        Returns:
            None
        """
        pass

    def BeginPolygons(self, type, color, alpha, stip, offsetX, offsetY, fill, cull):
        """BeginPolygons(integer type,vector color,float alpha,float stip,float offsetX,float offsetY,integer fill,integer cull)
        
        Args:
            type (int):
            color (tuple):
            alpha (float):
            stip (float):
            offsetX (float):
            offsetY (float):
            fill (int):
            cull (int):

        Returns:
            None
        """
        pass

    def BeginW(self, type, color, alpha, width):
        """BeginW(integer type,vector color,float alpha,float width)
        
        Args:
            type (int):
            color (tuple):
            alpha (float):
            width (float):

        Returns:
            None
        """
        pass

    def BeginWD(self, type, color, alpha, width, dashPattern):
        """BeginWD(integer type,vector color,float alpha,float width,integer dashPattern)
        
        Args:
            type (int):
            color (tuple):
            alpha (float):
            width (float):
            dashPattern (int):

        Returns:
            None
        """
        pass

    def Image(self, texID, just):
        """Image(integer texID,integer just)
        
        Args:
            texID (int):
            just (int):

        Returns:
            None
        """
        pass

    def PopTransform(self):
        """PopTransform()
        
        Returns:
            None
        """
        pass

    def PushTransform(self, v, m):
        """PushTransform(vector v,matrix m)
        
        Args:
            v (tuple):
            m (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def SetPart(self, part):
        """SetPart(integer part)
        
        Args:
            part (int):

        Returns:
            None
        """
        pass

    def Text(self, text, just):
        """Text(string text,integer just)
        
        Args:
            text (str):
            just (int):

        Returns:
            None
        """
        pass

    def TextureUV(self, u, v):
        """TextureUV(float u,float v)
        
        Args:
            u (float):
            v (float):

        Returns:
            None
        """
        pass

    def Vertex(self, pos, flags):
        """Vertex(vector pos,integer flags)
        
        Args:
            pos (tuple):
            flags (int):

        Returns:
            None
        """
        pass

    def Vertex3(self, x, y, z, flags):
        """Vertex3(float x,float y,float z,integer flags)
        
        Args:
            x (float):
            y (float):
            z (float):
            flags (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Subdivision:
    """Subdivision"""
    def __init__(self, unknown=None):
        pass

    def Adaptive(self):
        """integer = Adaptive()
        
        Returns:
            int
        """
        pass

    def AddUVMap(self, name):
        """integer = AddUVMap(string name)
        
        Args:
            name (str):

        Returns:
            int
        """
        pass

    def Backend(self):
        """integer = Backend()
        
        Returns:
            int
        """
        pass

    def BoundaryRule(self):
        """integer = BoundaryRule()
        
        Returns:
            int
        """
        pass

    def ChildFace(self, faceIndex, vertOfFace):
        """integer = ChildFace(integer faceIndex,integer vertOfFace)
        
        Args:
            faceIndex (int):
            vertOfFace (int):

        Returns:
            int
        """
        pass

    def FaceDepth(self, faceIndex):
        """integer = FaceDepth(integer faceIndex)
        
        Args:
            faceIndex (int):

        Returns:
            int
        """
        pass

    def FirstFaceOffset(self, level):
        """integer = FirstFaceOffset(integer level)
        
        Args:
            level (int):

        Returns:
            int
        """
        pass

    def FirstVertexOffset(self, level):
        """integer = FirstVertexOffset(integer level)
        
        Args:
            level (int):

        Returns:
            int
        """
        pass

    def GetUV(self, mapIndex, faceIndex, vertOfFace):
        """float[] = GetUV(integer mapIndex,integer faceIndex,integer vertOfFace)
        
        Args:
            mapIndex (int):
            faceIndex (int):
            vertOfFace (int):

        Returns:
            float[]
        """
        pass

    def InvalidatePosition(self):
        """InvalidatePosition()
        
        Returns:
            None
        """
        pass

    def InvalidateTopology(self):
        """InvalidateTopology()
        
        Returns:
            None
        """
        pass

    def LookupUVMap(self, name):
        """integer = LookupUVMap(string name)
        
        Args:
            name (str):

        Returns:
            int
        """
        pass

    def MaxLevel(self):
        """integer = MaxLevel()
        
        Returns:
            int
        """
        pass

    def NumFaces(self):
        """integer = NumFaces()
        
        Returns:
            int
        """
        pass

    def NumLevelFaces(self, level):
        """integer = NumLevelFaces(integer level)
        
        Args:
            level (int):

        Returns:
            int
        """
        pass

    def NumLevelVertices(self, level):
        """integer = NumLevelVertices(integer level)
        
        Args:
            level (int):

        Returns:
            int
        """
        pass

    def NumUVMap(self):
        """integer = NumUVMap()
        
        Returns:
            int
        """
        pass

    def NumVertices(self):
        """integer = NumVertices()
        
        Returns:
            int
        """
        pass

    def NumVerticesOfFace(self, faceIndex):
        """integer = NumVerticesOfFace(integer faceIndex)
        
        Args:
            faceIndex (int):

        Returns:
            int
        """
        pass

    def ParentFace(self, faceIndex):
        """integer = ParentFace(integer faceIndex)
        
        Args:
            faceIndex (int):

        Returns:
            int
        """
        pass

    def ParentVertex(self, vertIndex):
        """integer = ParentVertex(integer vertIndex)
        
        Args:
            vertIndex (int):

        Returns:
            int
        """
        pass

    def Refine(self, mesh):
        """Refine(object mesh)
        
        Args:
            mesh (lxu.object.Mesh):

        Returns:
            None
        """
        pass

    def Scheme(self):
        """integer = Scheme()
        
        Returns:
            int
        """
        pass

    def SetAdaptive(self, adaptive):
        """integer = SetAdaptive(integer adaptive)
        
        Args:
            adaptive (int):

        Returns:
            int
        """
        pass

    def SetBackend(self, backend):
        """integer = SetBackend(integer backend)
        
        Args:
            backend (int):

        Returns:
            int
        """
        pass

    def SetBoundaryRule(self, bound):
        """integer = SetBoundaryRule(integer bound)
        
        Args:
            bound (int):

        Returns:
            int
        """
        pass

    def SetMaxLevel(self, level):
        """integer = SetMaxLevel(integer level)
        
        Args:
            level (int):

        Returns:
            int
        """
        pass

    def SetScheme(self, scheme):
        """integer = SetScheme(integer scheme)
        
        Args:
            scheme (int):

        Returns:
            int
        """
        pass

    def SetUVBoundaryRule(self, bound):
        """integer = SetUVBoundaryRule(integer bound)
        
        Args:
            bound (int):

        Returns:
            int
        """
        pass

    def Status(self):
        """integer = Status()
        
        Returns:
            int
        """
        pass

    def UVBoundaryRule(self):
        """integer = UVBoundaryRule()
        
        Returns:
            int
        """
        pass

    def UVMapName(self, mapIndex):
        """string = UVMapName(integer mapIndex)
        
        Args:
            mapIndex (int):

        Returns:
            str
        """
        pass

    def Validate(self, mesh):
        """Validate(object mesh)
        
        Args:
            mesh (lxu.object.Mesh):

        Returns:
            None
        """
        pass

    def VertexNormal(self, vertIndex):
        """float[] = VertexNormal(integer vertIndex)
        
        Args:
            vertIndex (int):

        Returns:
            float[]
        """
        pass

    def VertexOfFace(self, faceIndex, vertofface):
        """integer = VertexOfFace(integer faceIndex,integer vertofface)
        
        Args:
            faceIndex (int):
            vertofface (int):

        Returns:
            int
        """
        pass

    def VertexPosition(self, vertIndex):
        """float[] = VertexPosition(integer vertIndex)
        
        Args:
            vertIndex (int):

        Returns:
            float[]
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Subject2Packet:
    """Subject2Packet"""
    def __init__(self, unknown=None):
        pass

    def ScanAllocate(self, flags):
        """LayerScan object = ScanAllocate(integer flags)
        
        Args:
            flags (int):

        Returns:
            object (LayerScan):
        """
        pass

    def Type(self):
        """integer = Type()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Surface:
    """Surface"""
    def __init__(self, unknown=None):
        pass

    def BinByIndex(self, index):
        """SurfaceBin object = BinByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (SurfaceBin):
        """
        pass

    def BinCount(self):
        """integer count = BinCount()
        
        Returns:
            count (int):
        """
        pass

    def FrontBBox(self, pos, dir):
        """bounds bbox = FrontBBox(vector pos,vector dir)
        
        Args:
            pos (tuple):
            dir (tuple):

        Returns:
            bbox (bounds):
        """
        pass

    def GLCount(self):
        """integer count = GLCount()
        
        Returns:
            count (int):
        """
        pass

    def GetBBox(self):
        """bounds bbox = GetBBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def TagByIndex(self, type, index):
        """string stag = TagByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            stag (str):
        """
        pass

    def TagCount(self, type):
        """integer count = TagCount(integer type)
        
        Args:
            type (int):

        Returns:
            count (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SurfaceBin:
    """SurfaceBin"""
    def __init__(self, unknown=None):
        pass

    def FrontBBox(self, pos, dir):
        """bounds bbox = FrontBBox(vector pos,vector dir)
        
        Args:
            pos (tuple):
            dir (tuple):

        Returns:
            bbox (bounds):
        """
        pass

    def GetBBox(self):
        """bounds bbox = GetBBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SurfaceItem:
    """SurfaceItem"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self, attr, index):
        """Surface object = Evaluate(object attr,integer index)
        
        Args:
            attr (attr):
            index (int):

        Returns:
            object (Surface):
        """
        pass

    def GetSurface(self, chanRead, morph):
        """Surface object = GetSurface(object chanRead,integer morph)
        
        Args:
            chanRead (chanRead):
            morph (int):

        Returns:
            object (Surface):
        """
        pass

    def Prepare(self, eval):
        """integer index = Prepare(object eval)
        
        Args:
            eval (eval):

        Returns:
            index (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class SymmetryPacket:
    """SymmetryPacket"""
    def __init__(self, unknown=None):
        pass

    def Active(self):
        """integer = Active()
        
        Returns:
            int
        """
        pass

    def Axis(self):
        """(integer,vector axvec,float offset) = Axis()
        
        Returns:
            (integer,vector axvec,float offset)
        """
        pass

    def BaseSide(self):
        """integer = BaseSide()
        
        Returns:
            int
        """
        pass

    def Position(self, pos):
        """(integer,vector sv) = Position(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            sv) ((integer,vector):
        """
        pass

    def SetBase(self, pos):
        """SetBase(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            None
        """
        pass

    def TestSide(self, pos, useBase):
        """integer = TestSide(vector pos,integer useBase)
        
        Args:
            pos (tuple):
            useBase (int):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Tableau:
    """Tableau"""
    def __init__(self, unknown=None):
        pass

    def AddElement(self, element, shader):
        """AddElement(object element,object shader)
        
        Args:
            element (element):
            shader (shader):

        Returns:
            None
        """
        pass

    def AddInstance(self, inst, element, shader):
        """AddInstance(object inst,object element,object shader)
        
        Args:
            inst (inst):
            element (element):
            shader (shader):

        Returns:
            None
        """
        pass

    def AddInstanceItem(self, instItem, fromItem, inst, vdesc, vertex):
        """AddInstanceItem(object instItem,object fromItem,object inst,object vdesc,float[] vertex)
        
        Args:
            instItem (instItem):
            fromItem (fromItem):
            inst (inst):
            vdesc (vdesc):
            vertex (float[]):

        Returns:
            None
        """
        pass

    def AddInstanceableElement(self, elt, tags):
        """AddInstanceableElement(object elt,object tags)
        
        Args:
            elt (elt):
            tags (tags):

        Returns:
            None
        """
        pass

    def Channels(self, type):
        """ChannelRead object = Channels(integer type)
        
        Args:
            type (int):

        Returns:
            object (ChannelRead):
        """
        pass

    def EltNotify(self, element, event):
        """EltNotify(object element,integer event)
        
        Args:
            element (element):
            event (int):

        Returns:
            None
        """
        pass

    def FindShader(self, item, tags):
        """TableauShader object = FindShader(object item,object tags)
        
        Args:
            item (lxu.object.Item):
            tags (tags):

        Returns:
            object (TableauShader):
        """
        pass

    def InstNotify(self, instance, event):
        """InstNotify(object instance,integer event)
        
        Args:
            instance (instance):
            event (int):

        Returns:
            None
        """
        pass

    def InstanceItem(self):
        """object = InstanceItem()
        
        Returns:
            object
        """
        pass

    def Time(self):
        """(float t0,float interval) = Time()
        
        Returns:
            (float t0,float interval)
        """
        pass

    def Update(self, visitor, immediate):
        """Update(object visitor,integer immediate)
        
        Args:
            visitor (visitor):
            immediate (int):

        Returns:
            None
        """
        pass

    def UpdateAll(self):
        """UpdateAll()
        
        Returns:
            None
        """
        pass

    def Visible(self, item):
        """boolean = Visible(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauElement:
    """TableauElement"""
    def __init__(self, unknown=None):
        pass

    def Bound(self):
        """bounds bbox = Bound()
        
        Returns:
            bbox (bounds):
        """
        pass

    def FeatureByIndex(self, type, index):
        """string name = FeatureByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            name (str):
        """
        pass

    def FeatureCount(self, type):
        """integer = FeatureCount(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def SetVertex(self, vdesc):
        """SetVertex(object vdesc)
        
        Args:
            vdesc (vdesc):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauInstance:
    """TableauInstance"""
    def __init__(self, unknown=None):
        pass

    def GetDissolve(self):
        """float dissolve = GetDissolve()
        
        Returns:
            dissolve (float):
        """
        pass

    def GetTransform(self, endPoint):
        """(vector offset,matrix xfrm) = GetTransform(integer endPoint)
        
        Args:
            endPoint (int):

        Returns:
            (vector offset,matrix xfrm)
        """
        pass

    def ParticleArray(self):
        """float vector = ParticleArray()
        
        Returns:
            vector (float):
        """
        pass

    def ParticleDescription(self):
        """Unknown object = ParticleDescription()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Properties(self, vecstack):
        """Properties(object vecstack)
        
        Args:
            vecstack (vecstack):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauLight:
    """TableauLight"""
    def __init__(self, unknown=None):
        pass

    def Bound(self):
        """bounds bbox = Bound()
        
        Returns:
            bbox (bounds):
        """
        pass

    def FeatureByIndex(self, type, index):
        """string name = FeatureByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            name (str):
        """
        pass

    def FeatureCount(self, type):
        """integer = FeatureCount(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def Geometry(self, gc):
        """integer = Geometry(pointer gc)
        
        Args:
            gc (int):

        Returns:
            int
        """
        pass

    def Sample(self, u, v, dir, t):
        """(vector wPos,vector oPos,vector norm) = Sample(float u,float v,vector dir,float t)
        
        Args:
            u (float):
            v (float):
            dir (tuple):
            t (float):

        Returns:
            (vector wPos,vector oPos,vector norm)
        """
        pass

    def SetVertex(self, vdesc):
        """SetVertex(object vdesc)
        
        Args:
            vdesc (vdesc):

        Returns:
            None
        """
        pass

    def ShadowMap(self):
        """(integer,Unknown object) = ShadowMap()
        
        Returns:
            object) ((integer,Unknown):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauProxy:
    """TableauProxy"""
    def __init__(self, unknown=None):
        pass

    def Bound(self):
        """bounds bbox = Bound()
        
        Returns:
            bbox (bounds):
        """
        pass

    def FeatureByIndex(self, type, index):
        """string name = FeatureByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            name (str):
        """
        pass

    def FeatureCount(self, type):
        """integer = FeatureCount(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def Sample(self, bbox, tableau):
        """Sample(bounds bbox,object tableau)
        
        Args:
            bbox (bounds):
            tableau (tableau):

        Returns:
            None
        """
        pass

    def SetVertex(self, vdesc):
        """SetVertex(object vdesc)
        
        Args:
            vdesc (vdesc):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauShader:
    """TableauShader"""
    def __init__(self, unknown=None):
        pass

    def Select(self, teElt, tvDesc):
        """Select(object teElt,object tvDesc)
        
        Args:
            teElt (teElt):
            tvDesc (tvDesc):

        Returns:
            None
        """
        pass

    def Slice(self, vtOutput, tvDesc):
        """ShaderSlice object = Slice(object vtOutput,object tvDesc)
        
        Args:
            vtOutput (vtOutput):
            tvDesc (tvDesc):

        Returns:
            object (ShaderSlice):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauSource:
    """TableauSource"""
    def __init__(self, unknown=None):
        pass

    def ElementType(self, type):
        """integer supported = ElementType(integer type)
        
        Args:
            type (int):

        Returns:
            supported (int):
        """
        pass

    def Elements(self, tableau):
        """Elements(object tableau)
        
        Args:
            tableau (tableau):

        Returns:
            None
        """
        pass

    def GetCurves(self, tableau, tags):
        """Unknown object = GetCurves(object tableau,object tags)
        
        Args:
            tableau (tableau):
            tags (tags):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Instance(self, tableau, instance):
        """Instance(object tableau,object instance)
        
        Args:
            tableau (tableau):
            instance (instance):

        Returns:
            None
        """
        pass

    def Preview(self, tableau):
        """Preview(object tableau)
        
        Args:
            tableau (tableau):

        Returns:
            None
        """
        pass

    def PreviewUpdate(self, chanIndex):
        """integer update = PreviewUpdate(integer chanIndex)
        
        Args:
            chanIndex (int):

        Returns:
            update (int):
        """
        pass

    def SubShader(self, tableau):
        """Unknown object = SubShader(object tableau)
        
        Args:
            tableau (tableau):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauSurface:
    """TableauSurface"""
    def __init__(self, unknown=None):
        pass

    def Bound(self):
        """bounds bbox = Bound()
        
        Returns:
            bbox (bounds):
        """
        pass

    def FeatureByIndex(self, type, index):
        """string name = FeatureByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            name (str):
        """
        pass

    def FeatureCount(self, type):
        """integer = FeatureCount(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def Padding(self):
        """float dist = Padding()
        
        Returns:
            dist (float):
        """
        pass

    def Sample(self, bbox, scale, trisoup):
        """Sample(bounds bbox,float scale,object trisoup)
        
        Args:
            bbox (bounds):
            scale (float):
            trisoup (trisoup):

        Returns:
            None
        """
        pass

    def SegmentBox(self, segID):
        """bounds bbox = SegmentBox(integer segID)
        
        Args:
            segID (int):

        Returns:
            bbox (bounds):
        """
        pass

    def SetVertex(self, vdesc):
        """SetVertex(object vdesc)
        
        Args:
            vdesc (vdesc):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauVertex:
    """TableauVertex"""
    def __init__(self, unknown=None):
        pass

    def AddFeature(self, type, name):
        """integer index = AddFeature(integer type,string name)
        
        Args:
            type (int):
            name (str):

        Returns:
            index (int):
        """
        pass

    def ByIndex(self, index):
        """(integer type,string name,integer offset) = ByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (integer type,string name,integer offset)
        """
        pass

    def Count(self):
        """integer = Count()
        
        Returns:
            int
        """
        pass

    def Lookup(self, type, name):
        """integer offset = Lookup(integer type,string name)
        
        Args:
            type (int):
            name (str):

        Returns:
            offset (int):
        """
        pass

    def Size(self):
        """integer = Size()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TableauVolume:
    """TableauVolume"""
    def __init__(self, unknown=None):
        pass

    def Bound(self):
        """bounds bbox = Bound()
        
        Returns:
            bbox (bounds):
        """
        pass

    def Density(self, densitySlice, sv, raycastObj, pos, worldPos):
        """float dens = Density(object densitySlice,object sv,object raycastObj,vector pos,integer worldPos)
        
        Args:
            densitySlice (densitySlice):
            sv (sv):
            raycastObj (raycastObj):
            pos (tuple):
            worldPos (int):

        Returns:
            dens (float):
        """
        pass

    def FeatureByIndex(self, type, index):
        """string name = FeatureByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            name (str):
        """
        pass

    def FeatureCount(self, type):
        """integer = FeatureCount(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def RayCast(self, densitySlice, sv, raycastObj):
        """(float dist,integer localShader) = RayCast(object densitySlice,object sv,object raycastObj)
        
        Args:
            densitySlice (densitySlice):
            sv (sv):
            raycastObj (raycastObj):

        Returns:
            (float dist,integer localShader)
        """
        pass

    def RaySample(self, densitySlice, shadingSlice, sv, raycastObj, raymarchObj):
        """RaySample(object densitySlice,object shadingSlice,object sv,object raycastObj,object raymarchObj)
        
        Args:
            densitySlice (densitySlice):
            shadingSlice (shadingSlice):
            sv (sv):
            raycastObj (raycastObj):
            raymarchObj (raymarchObj):

        Returns:
            None
        """
        pass

    def RenderInit(self, sv):
        """RenderInit(object sv)
        
        Args:
            sv (sv):

        Returns:
            None
        """
        pass

    def SetVertex(self, vdesc):
        """SetVertex(object vdesc)
        
        Args:
            vdesc (vdesc):

        Returns:
            None
        """
        pass

    def Type(self):
        """integer = Type()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TagDescription:
    """TagDescription"""
    def __init__(self, unknown=None):
        pass

    def Count(self):
        """integer = Count()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TextEncoding:
    """TextEncoding"""
    def __init__(self, unknown=None):
        pass

    def Convert(self, src, buf, max):
        """Convert(string src,byte[] buf,integer max)
        
        Args:
            src (str):
            buf (byte[]):
            max (int):

        Returns:
            None
        """
        pass

    def Default(self):
        """integer = Default()
        
        Returns:
            int
        """
        pass

    def NumChar(self, string, target):
        """integer = NumChar(string string,integer target)
        
        Args:
            string (str):
            target (int):

        Returns:
            int
        """
        pass

    def PullChar(self, string, target):
        """(string,integer code,integer len) = PullChar(string string,integer target)
        
        Args:
            string (str):
            target (int):

        Returns:
            (string,integer code,integer len)
        """
        pass

    def SetSource(self, encoding):
        """SetSource(integer encoding)
        
        Args:
            encoding (int):

        Returns:
            None
        """
        pass

    def SetTarget(self, encoding):
        """SetTarget(integer encoding)
        
        Args:
            encoding (int):

        Returns:
            None
        """
        pass

    def Source(self):
        """integer = Source()
        
        Returns:
            int
        """
        pass

    def Target(self):
        """integer = Target()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TextScriptInterpreter:
    """TextScriptInterpreter"""
    def __init__(self, unknown=None):
        pass

    def Run(self, script, execFlags, args, msg):
        """Run(object script,integer execFlags,string args,object msg)
        
        Args:
            script (script):
            execFlags (int):
            args (str):
            msg (msg):

        Returns:
            None
        """
        pass

    def Validate(self, script, msg):
        """boolean = Validate(object script,object msg)
        
        Args:
            script (script):
            msg (msg):

        Returns:
            bool
        """
        pass

    def ValidateFileType(self, script, firstLine):
        """boolean = ValidateFileType(object script,string firstLine)
        
        Args:
            script (script):
            firstLine (str):

        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Texture:
    """Texture"""
    def __init__(self, unknown=None):
        pass

    def Effect(self):
        """string = Effect()
        
        Returns:
            str
        """
        pass

    def EvalImage(self, scene):
        """Image object = EvalImage(object scene)
        
        Args:
            scene (scene):

        Returns:
            object (lx.object.Image):
        """
        pass

    def Image(self):
        """Item object = Image()
        
        Returns:
            object (lxu.object.Item):
        """
        pass

    def ImageName(self):
        """string = ImageName()
        
        Returns:
            str
        """
        pass

    def Locator(self):
        """Item object = Locator()
        
        Returns:
            object (lxu.object.Item):
        """
        pass

    def LocatorProjectionAxis(self, time):
        """integer = LocatorProjectionAxis(float time)
        
        Args:
            time (float):

        Returns:
            int
        """
        pass

    def LocatorProjectionMode(self, time):
        """integer = LocatorProjectionMode(float time)
        
        Args:
            time (float):

        Returns:
            int
        """
        pass

    def SetEffect(self, effect):
        """SetEffect(string effect)
        
        Args:
            effect (str):

        Returns:
            None
        """
        pass

    def SetImage(self, img):
        """SetImage(object img)
        
        Args:
            img (img):

        Returns:
            None
        """
        pass

    def SetLocator(self, tloc):
        """SetLocator(object tloc)
        
        Args:
            tloc (tloc):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TextureEffect:
    """TextureEffect"""
    def __init__(self, unknown=None):
        pass

    def Get(self, sv, item):
        """float val = Get(object sv,pointer item)
        
        Args:
            sv (sv):
            item (int):

        Returns:
            val (float):
        """
        pass

    def Set(self, sv, val, item):
        """Set(object sv,float[] val,pointer item)
        
        Args:
            sv (sv):
            val (float[]):
            item (int):

        Returns:
            None
        """
        pass

    def Type(self):
        """integer = Type()
        
        Returns:
            int
        """
        pass

    def TypeName(self):
        """string = TypeName()
        
        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TexturePacket:
    """TexturePacket"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ThreadGroup:
    """ThreadGroup"""
    def __init__(self, unknown=None):
        pass

    def AddJob(self, job):
        """AddJob(object job)
        
        Args:
            job (job):

        Returns:
            None
        """
        pass

    def Clear(self):
        """Clear()
        
        Returns:
            None
        """
        pass

    def Execute(self):
        """Execute()
        
        Returns:
            None
        """
        pass

    def Kill(self):
        """Kill()
        
        Returns:
            None
        """
        pass

    def NumJobs(self):
        """integer = NumJobs()
        
        Returns:
            int
        """
        pass

    def Running(self):
        """boolean = Running()
        
        Returns:
            bool
        """
        pass

    def Wait(self):
        """Wait()
        
        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ThreadJob:
    """ThreadJob"""
    def __init__(self, unknown=None):
        pass

    def Execute(self):
        """Execute()
        
        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ThreadMutex:
    """ThreadMutex"""
    def __init__(self, unknown=None):
        pass

    def Enter(self):
        """Enter()
        
        Returns:
            None
        """
        pass

    def Leave(self):
        """Leave()
        
        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ThreadRangeWorker:
    """ThreadRangeWorker"""
    def __init__(self, unknown=None):
        pass

    def Execute(self, index, sharedData):
        """Execute(integer index,pointer sharedData)
        
        Args:
            index (int):
            sharedData (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ThreadSlot:
    """ThreadSlot"""
    def __init__(self, unknown=None):
        pass

    def Clear(self):
        """Clear()
        
        Returns:
            None
        """
        pass

    def Set(self, value):
        """Set(pointer value)
        
        Args:
            value (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ThreadSlotClient:
    """ThreadSlotClient"""
    def __init__(self, unknown=None):
        pass

    def Free(self, value):
        """Free(pointer value)
        
        Args:
            value (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TileImage:
    """TileImage"""
    def __init__(self, unknown=None):
        pass

    def DeterminePixel(self, level, x, y):
        """(integer adjX,integer adjY) = DeterminePixel(integer level,integer x,integer y)
        
        Args:
            level (int):
            x (int):
            y (int):

        Returns:
            (integer adjX,integer adjY)
        """
        pass

    def DetermineTile(self, level, x, y):
        """(integer tileX,integer tileY) = DetermineTile(integer level,integer x,integer y)
        
        Args:
            level (int):
            x (int):
            y (int):

        Returns:
            (integer tileX,integer tileY)
        """
        pass

    def GetLevelSize(self, level):
        """(integer width,integer height,integer tilesWidth,integer tilesHeight) = GetLevelSize(integer level)
        
        Args:
            level (int):

        Returns:
            (integer width,integer height,integer tilesWidth,integer tilesHeight)
        """
        pass

    def GetTile(self, level, tileX, tileY):
        """Image object = GetTile(integer level,integer tileX,integer tileY)
        
        Args:
            level (int):
            tileX (int):
            tileY (int):

        Returns:
            object (lx.object.Image):
        """
        pass

    def GetTileSize(self, level, tileX, tileY):
        """(integer width,integer height) = GetTileSize(integer level,integer tileX,integer tileY)
        
        Args:
            level (int):
            tileX (int):
            tileY (int):

        Returns:
            (integer width,integer height)
        """
        pass

    def LevelCount(self):
        """integer = LevelCount()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Tool:
    """Tool"""
    def __init__(self, unknown=None):
        pass

    def CompareOp(self, vts, toolop):
        """integer = CompareOp(object vts,object toolop)
        
        Args:
            vts (vts):
            toolop (toolop):

        Returns:
            int
        """
        pass

    def Evaluate(self, vts):
        """Evaluate(object vts)
        
        Args:
            vts (vts):

        Returns:
            None
        """
        pass

    def GetOp(self, flags):
        """Unknown object = GetOp(integer flags)
        
        Args:
            flags (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def Order(self):
        """string = Order()
        
        Returns:
            str
        """
        pass

    def Reset(self):
        """Reset()
        
        Returns:
            None
        """
        pass

    def Sequence(self, seq):
        """Sequence(object seq)
        
        Args:
            seq (seq):

        Returns:
            None
        """
        pass

    def ShouldBeAttribute(self, task):
        """integer = ShouldBeAttribute(integer task)
        
        Args:
            task (int):

        Returns:
            int
        """
        pass

    def Task(self):
        """integer = Task()
        
        Returns:
            int
        """
        pass

    def UpdateOp(self, toolop):
        """UpdateOp(object toolop)
        
        Args:
            toolop (toolop):

        Returns:
            None
        """
        pass

    def VectorType(self):
        """object = VectorType()
        
        Returns:
            object
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ToolModel:
    """ToolModel"""
    def __init__(self, unknown=None):
        pass

    def AllowOverride(self, attrName, mouseInput, haulAxis):
        """AllowOverride(string attrName,integer mouseInput,integer haulAxis)
        
        Args:
            attrName (str):
            mouseInput (int):
            haulAxis (int):

        Returns:
            None
        """
        pass

    def Down(self, vts, adjust):
        """Down(object vts,object adjust)
        
        Args:
            vts (vts):
            adjust (adjust):

        Returns:
            None
        """
        pass

    def Draw(self, vts, stroke, flags):
        """Draw(object vts,object stroke,integer flags)
        
        Args:
            vts (vts):
            stroke (stroke):
            flags (int):

        Returns:
            None
        """
        pass

    def Drop(self):
        """Drop()
        
        Returns:
            None
        """
        pass

    def Enable(self, msg):
        """Enable(object msg)
        
        Args:
            msg (msg):

        Returns:
            None
        """
        pass

    def Filter(self, vts, adjust):
        """Filter(object vts,object adjust)
        
        Args:
            vts (vts):
            adjust (adjust):

        Returns:
            None
        """
        pass

    def Flags(self):
        """integer = Flags()
        
        Returns:
            int
        """
        pass

    def Haul(self, index):
        """string = Haul(integer index)
        
        Args:
            index (int):

        Returns:
            str
        """
        pass

    def Help(self, vts):
        """string = Help(object vts)
        
        Args:
            vts (vts):

        Returns:
            str
        """
        pass

    def Initialize(self, vts, adjust, flags):
        """Initialize(object vts,object adjust,integer flags)
        
        Args:
            vts (vts):
            adjust (adjust):
            flags (int):

        Returns:
            None
        """
        pass

    def Move(self, vts, adjust):
        """Move(object vts,object adjust)
        
        Args:
            vts (vts):
            adjust (adjust):

        Returns:
            None
        """
        pass

    def Post(self, vts):
        """Post(object vts)
        
        Args:
            vts (vts):

        Returns:
            None
        """
        pass

    def Test(self, vts, stroke, flags):
        """Test(object vts,object stroke,integer flags)
        
        Args:
            vts (vts):
            stroke (stroke):
            flags (int):

        Returns:
            None
        """
        pass

    def TestType(self, type):
        """TestType(integer type)
        
        Args:
            type (int):

        Returns:
            None
        """
        pass

    def Tooltip(self, vts, part):
        """string = Tooltip(object vts,integer part)
        
        Args:
            vts (vts):
            part (int):

        Returns:
            str
        """
        pass

    def Track(self, vts, eventType):
        """Track(object vts,integer eventType)
        
        Args:
            vts (vts):
            eventType (int):

        Returns:
            None
        """
        pass

    def TrackFlags(self):
        """integer flags = TrackFlags()
        
        Returns:
            flags (int):
        """
        pass

    def Up(self, vts, adjust):
        """Up(object vts,object adjust)
        
        Args:
            vts (vts):
            adjust (adjust):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ToolOperation:
    """ToolOperation"""
    def __init__(self, unknown=None):
        pass

    def Blend(self, other, blend):
        """Blend(object other,object blend)
        
        Args:
            other (other):
            blend (blend):

        Returns:
            None
        """
        pass

    def Evaluate(self, vts):
        """Evaluate(object vts)
        
        Args:
            vts (vts):

        Returns:
            None
        """
        pass

    def ReEvaluate(self, vts):
        """ReEvaluate(object vts)
        
        Args:
            vts (vts):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TransformScan:
    """TransformScan"""
    def __init__(self, unknown=None):
        pass

    def AlternateAxis(self):
        """(matrix matrix,matrix inverse) = AlternateAxis()
        
        Returns:
            (matrix matrix,matrix inverse)
        """
        pass

    def AlternateCenter(self):
        """vector center = AlternateCenter()
        
        Returns:
            center (tuple):
        """
        pass

    def Enumerate(self, visitor):
        """Enumerate(object visitor)
        
        Args:
            visitor (visitor):

        Returns:
            None
        """
        pass

    def Flags(self):
        """integer = Flags()
        
        Returns:
            int
        """
        pass

    def Position(self):
        """float[] = Position()
        
        Returns:
            float[]
        """
        pass

    def SetPosition(self):
        """vector pos = SetPosition()
        
        Returns:
            pos (tuple):
        """
        pass

    def Weight(self):
        """float = Weight()
        
        Returns:
            float
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Tree:
    """Tree"""
    def __init__(self, unknown=None):
        pass

    def ChildIsLeaf(self):
        """boolean = ChildIsLeaf()
        
        Returns:
            bool
        """
        pass

    def Count(self):
        """integer count = Count()
        
        Returns:
            count (int):
        """
        pass

    def Current(self):
        """integer index = Current()
        
        Returns:
            index (int):
        """
        pass

    def IsRoot(self):
        """boolean = IsRoot()
        
        Returns:
            bool
        """
        pass

    def ItemState(self, guid):
        """integer state = ItemState(string guid)
        
        Args:
            guid (str):

        Returns:
            state (int):
        """
        pass

    def SetCurrent(self, index):
        """SetCurrent(integer index)
        
        Args:
            index (int):

        Returns:
            None
        """
        pass

    def SetItemState(self, guid, state):
        """SetItemState(string guid,integer state)
        
        Args:
            guid (str):
            state (int):

        Returns:
            None
        """
        pass

    def Spawn(self, mode):
        """Tree object = Spawn(integer mode)
        
        Args:
            mode (int):

        Returns:
            object (Tree):
        """
        pass

    def ToChild(self):
        """ToChild()
        
        Returns:
            None
        """
        pass

    def ToParent(self):
        """ToParent()
        
        Returns:
            None
        """
        pass

    def ToRoot(self):
        """ToRoot()
        
        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TreeListener:
    """TreeListener"""
    def __init__(self, unknown=None):
        pass

    def ClearAllCachedThumbnails(self):
        """ClearAllCachedThumbnails()
        
        Returns:
            None
        """
        pass

    def ClearCachedThumbnail(self, ident):
        """ClearCachedThumbnail(string ident)
        
        Args:
            ident (str):

        Returns:
            None
        """
        pass

    def NewAttributes(self):
        """NewAttributes()
        
        Returns:
            None
        """
        pass

    def NewShape(self):
        """NewShape()
        
        Returns:
            None
        """
        pass

    def NewShowDescriptionText(self):
        """NewShowDescriptionText()
        
        Returns:
            None
        """
        pass

    def NewSpaceForThumbnails(self):
        """NewSpaceForThumbnails()
        
        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TreeView:
    """TreeView"""
    def __init__(self, unknown=None):
        pass

    def BadgeDetail(self, columnIndex, badgeIndex, badgeDetail):
        """string = BadgeDetail(integer columnIndex,integer badgeIndex,integer badgeDetail)
        
        Args:
            columnIndex (int):
            badgeIndex (int):
            badgeDetail (int):

        Returns:
            str
        """
        pass

    def BadgeType(self, columnIndex, badgeIndex):
        """integer badgeType = BadgeType(integer columnIndex,integer badgeIndex)
        
        Args:
            columnIndex (int):
            badgeIndex (int):

        Returns:
            badgeType (int):
        """
        pass

    def BadgeType2(self, columnIndex, badgeIndex):
        """integer badgeType = BadgeType2(integer columnIndex,integer badgeIndex)
        
        Args:
            columnIndex (int):
            badgeIndex (int):

        Returns:
            badgeType (int):
        """
        pass

    def BatchCommand(self, columnIndex):
        """string = BatchCommand(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            str
        """
        pass

    def CanFilter(self):
        """boolean = CanFilter()
        
        Returns:
            bool
        """
        pass

    def CellCommand(self, columnIndex):
        """string = CellCommand(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            str
        """
        pass

    def ColumnByIndex(self, columnIndex):
        """(string,integer columnWidth) = ColumnByIndex(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            columnWidth) ((string,integer):
        """
        pass

    def ColumnCount(self):
        """integer colCount = ColumnCount()
        
        Returns:
            colCount (int):
        """
        pass

    def ColumnIconResource(self, columnIndex):
        """string = ColumnIconResource(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            str
        """
        pass

    def ColumnInternalName(self, columnIndex):
        """string = ColumnInternalName(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            str
        """
        pass

    def ColumnJustification(self, columnIndex):
        """integer justification = ColumnJustification(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            justification (int):
        """
        pass

    def DescriptionText(self, columnIndex):
        """string = DescriptionText(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            str
        """
        pass

    def Filter(self):
        """integer flags = Filter()
        
        Returns:
            flags (int):
        """
        pass

    def GetDragDropDestinationObject(self, columnIndex, location):
        """Unknown object = GetDragDropDestinationObject(integer columnIndex,integer location)
        
        Args:
            columnIndex (int):
            location (int):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def GetDragDropSourceObject(self, columnIndex, type):
        """Unknown object = GetDragDropSourceObject(integer columnIndex,string type)
        
        Args:
            columnIndex (int):
            type (str):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def IconResource(self, columnIndex, width, height):
        """string = IconResource(integer columnIndex,integer width,integer height)
        
        Args:
            columnIndex (int):
            width (int):
            height (int):

        Returns:
            str
        """
        pass

    def IsDescendantSelected(self):
        """boolean = IsDescendantSelected()
        
        Returns:
            bool
        """
        pass

    def IsInputRegion(self, columnIndex, regionID):
        """boolean = IsInputRegion(integer columnIndex,integer regionID)
        
        Args:
            columnIndex (int):
            regionID (int):

        Returns:
            bool
        """
        pass

    def IsSelected(self):
        """boolean = IsSelected()
        
        Returns:
            bool
        """
        pass

    def PrimaryColumnPosition(self):
        """integer index = PrimaryColumnPosition()
        
        Returns:
            index (int):
        """
        pass

    def ReservedSpaceForIcons(self):
        """(integer columnIndex,integer width,integer height,integer iconAsValue) = ReservedSpaceForIcons()
        
        Returns:
            (integer columnIndex,integer width,integer height,integer iconAsValue)
        """
        pass

    def ReservedSpaceForThumbnails(self):
        """(integer columnIndex,integer width,integer height) = ReservedSpaceForThumbnails()
        
        Returns:
            (integer columnIndex,integer width,integer height)
        """
        pass

    def RestoreState(self, uid):
        """RestoreState(string uid)
        
        Args:
            uid (str):

        Returns:
            None
        """
        pass

    def Select(self, mode):
        """Select(integer mode)
        
        Args:
            mode (int):

        Returns:
            None
        """
        pass

    def ShowDescriptionText(self):
        """ShowDescriptionText()
        
        Returns:
            None
        """
        pass

    def StoreState(self, uid):
        """StoreState(string uid)
        
        Args:
            uid (str):

        Returns:
            None
        """
        pass

    def StyleHints(self):
        """integer flags = StyleHints()
        
        Returns:
            flags (int):
        """
        pass

    def SupportedDragDropSourceTypes(self, columnIndex):
        """string = SupportedDragDropSourceTypes(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            str
        """
        pass

    def Thumbnail(self, columnIndex, width, height):
        """(Image object,string) = Thumbnail(integer columnIndex,integer width,integer height)
        
        Args:
            columnIndex (int):
            width (int):
            height (int):

        Returns:
            object,string) ((Image):
        """
        pass

    def ToPrimary(self):
        """boolean = ToPrimary()
        
        Returns:
            bool
        """
        pass

    def ToolTip(self, columnIndex):
        """string = ToolTip(integer columnIndex)
        
        Args:
            columnIndex (int):

        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TriangleGroup:
    """TriangleGroup"""
    def __init__(self, unknown=None):
        pass

    def AddSurface(self):
        """TriangleSurface object = AddSurface()
        
        Returns:
            object (TriangleSurface):
        """
        pass

    def Cleanup(self):
        """Cleanup()
        
        Returns:
            None
        """
        pass

    def GetSurface(self, index):
        """TriangleSurface object = GetSurface(integer index)
        
        Args:
            index (int):

        Returns:
            object (TriangleSurface):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TriangleSoup:
    """TriangleSoup"""
    def __init__(self, unknown=None):
        pass

    def Connect(self, type):
        """Connect(integer type)
        
        Args:
            type (int):

        Returns:
            None
        """
        pass

    def Polygon(self, v0, v1, v2):
        """Polygon(integer v0,integer v1,integer v2)
        
        Args:
            v0 (int):
            v1 (int):
            v2 (int):

        Returns:
            None
        """
        pass

    def Segment(self, segID, type):
        """Segment(integer segID,integer type)
        
        Args:
            segID (int):
            type (int):

        Returns:
            None
        """
        pass

    def TestBox(self, bbox):
        """integer = TestBox(bounds bbox)
        
        Args:
            bbox (bounds):

        Returns:
            int
        """
        pass

    def Vertex(self, vertex):
        """integer index = Vertex(float[] vertex)
        
        Args:
            vertex (float[]):

        Returns:
            index (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class TriangleSurface:
    """TriangleSurface"""
    def __init__(self, unknown=None):
        pass

    def AddVector(self, type, name):
        """integer index = AddVector(integer type,string name)
        
        Args:
            type (int):
            name (str):

        Returns:
            index (int):
        """
        pass

    def FixNormals(self):
        """unsigned[] = FixNormals()
        
        Returns:
            unsigned[]
        """
        pass

    def GetSize(self):
        """(integer nvrt,integer ntri) = GetSize()
        
        Returns:
            (integer nvrt,integer ntri)
        """
        pass

    def SetEdge(self, edge):
        """unsigned[] = SetEdge(integer edge)
        
        Args:
            edge (int):

        Returns:
            unsigned[]
        """
        pass

    def SetEdgeCount(self, nedge):
        """SetEdgeCount(integer nedge)
        
        Args:
            nedge (int):

        Returns:
            None
        """
        pass

    def SetSize(self, nvrt, ntri):
        """SetSize(integer nvrt,integer ntri)
        
        Args:
            nvrt (int):
            ntri (int):

        Returns:
            None
        """
        pass

    def SetTriangle(self, tri):
        """unsigned[] = SetTriangle(integer tri)
        
        Args:
            tri (int):

        Returns:
            unsigned[]
        """
        pass

    def SetVector(self, index, vrt):
        """float[] = SetVector(integer index,integer vrt)
        
        Args:
            index (int):
            vrt (int):

        Returns:
            float[]
        """
        pass

    def Triangles(self):
        """unsigned[] = Triangles()
        
        Returns:
            unsigned[]
        """
        pass

    def Vector(self, index):
        """float[] = Vector(integer index)
        
        Args:
            index (int):

        Returns:
            float[]
        """
        pass

    def VectorInfo(self, index):
        """(integer type,string name,integer dim) = VectorInfo(integer index)
        
        Args:
            index (int):

        Returns:
            (integer type,string name,integer dim)
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class UIHints:
    """UIHints"""
    def __init__(self, unknown=None):
        pass

    def BooleanStyle(self, style):
        """BooleanStyle(integer style)
        
        Args:
            style (int):

        Returns:
            None
        """
        pass

    def ButtonHasPopoverDecoration(self, state):
        """ButtonHasPopoverDecoration(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def ChannelFlags(self, flags):
        """ChannelFlags(integer flags)
        
        Args:
            flags (int):

        Returns:
            None
        """
        pass

    def Class(self, c):
        """Class(string c)
        
        Args:
            c (str):

        Returns:
            None
        """
        pass

    def ClipChoiceSupportsGroups(self, flags):
        """ClipChoiceSupportsGroups(integer flags)
        
        Args:
            flags (int):

        Returns:
            None
        """
        pass

    def ForceUpdate(self):
        """ForceUpdate()
        
        Returns:
            None
        """
        pass

    def FormFilterPriority(self, priority):
        """FormFilterPriority(integer priority)
        
        Args:
            priority (int):

        Returns:
            None
        """
        pass

    def InfoTextUseSmallFont(self, state):
        """InfoTextUseSmallFont(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def Label(self, label):
        """Label(string label)
        
        Args:
            label (str):

        Returns:
            None
        """
        pass

    def MaxFloat(self, max):
        """MaxFloat(float max)
        
        Args:
            max (float):

        Returns:
            None
        """
        pass

    def MaxInt(self, max):
        """MaxInt(integer max)
        
        Args:
            max (int):

        Returns:
            None
        """
        pass

    def MinFloat(self, min):
        """MinFloat(float min)
        
        Args:
            min (float):

        Returns:
            None
        """
        pass

    def MinInt(self, min):
        """MinInt(integer min)
        
        Args:
            min (int):

        Returns:
            None
        """
        pass

    def StepFloat(self, step):
        """StepFloat(float step)
        
        Args:
            step (float):

        Returns:
            None
        """
        pass

    def StepInt(self, step):
        """StepInt(integer step)
        
        Args:
            step (int):

        Returns:
            None
        """
        pass

    def StringList(self):
        """string strings = StringList()
        
        Returns:
            strings (str):
        """
        pass

    def TextFixedWidthFont(self, state):
        """TextFixedWidthFont(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def TextLines(self, lines):
        """TextLines(integer lines)
        
        Args:
            lines (int):

        Returns:
            None
        """
        pass

    def TextPasswordMode(self, state):
        """TextPasswordMode(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def Track(self, state):
        """Track(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def ValuePresetCookie(self, cookie):
        """ValuePresetCookie(string cookie)
        
        Args:
            cookie (str):

        Returns:
            None
        """
        pass

    def VertmapAllowNone(self, state):
        """VertmapAllowNone(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def VertmapItemMode(self, state):
        """VertmapItemMode(integer state)
        
        Args:
            state (int):

        Returns:
            None
        """
        pass

    def VertmapType(self, type):
        """VertmapType(integer type)
        
        Args:
            type (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class UIHintsRead:
    """UIHintsRead"""
    def __init__(self, unknown=None):
        pass

    def BooleanStyle(self):
        """integer style = BooleanStyle()
        
        Returns:
            style (int):
        """
        pass

    def ButtonHasPopoverDecoration(self):
        """integer state = ButtonHasPopoverDecoration()
        
        Returns:
            state (int):
        """
        pass

    def ChannelFlags(self):
        """integer flags = ChannelFlags()
        
        Returns:
            flags (int):
        """
        pass

    def Class(self):
        """string = Class()
        
        Returns:
            str
        """
        pass

    def ClipChoiceSupportsGroups(self):
        """integer flags = ClipChoiceSupportsGroups()
        
        Returns:
            flags (int):
        """
        pass

    def ForceUpdate(self):
        """integer state = ForceUpdate()
        
        Returns:
            state (int):
        """
        pass

    def FormFilterPriority(self):
        """integer priority = FormFilterPriority()
        
        Returns:
            priority (int):
        """
        pass

    def InfoTextUseSmallFont(self):
        """integer state = InfoTextUseSmallFont()
        
        Returns:
            state (int):
        """
        pass

    def Label(self):
        """string = Label()
        
        Returns:
            str
        """
        pass

    def MaxFloat(self):
        """float max = MaxFloat()
        
        Returns:
            max (float):
        """
        pass

    def MaxInt(self):
        """integer max = MaxInt()
        
        Returns:
            max (int):
        """
        pass

    def MinFloat(self):
        """float min = MinFloat()
        
        Returns:
            min (float):
        """
        pass

    def MinInt(self):
        """integer min = MinInt()
        
        Returns:
            min (int):
        """
        pass

    def StepFloat(self):
        """float step = StepFloat()
        
        Returns:
            step (float):
        """
        pass

    def StepInt(self):
        """integer step = StepInt()
        
        Returns:
            step (int):
        """
        pass

    def StringListByIndex(self, index):
        """string = StringListByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            str
        """
        pass

    def StringListCount(self):
        """integer count = StringListCount()
        
        Returns:
            count (int):
        """
        pass

    def TextFixedWidthFont(self):
        """integer state = TextFixedWidthFont()
        
        Returns:
            state (int):
        """
        pass

    def TextLines(self):
        """integer lines = TextLines()
        
        Returns:
            lines (int):
        """
        pass

    def TextPasswordMode(self):
        """integer state = TextPasswordMode()
        
        Returns:
            state (int):
        """
        pass

    def Track(self):
        """integer state = Track()
        
        Returns:
            state (int):
        """
        pass

    def ValuePresetCookie(self):
        """string = ValuePresetCookie()
        
        Returns:
            str
        """
        pass

    def VertmapAllowNone(self):
        """integer state = VertmapAllowNone()
        
        Returns:
            state (int):
        """
        pass

    def VertmapItemMode(self):
        """integer state = VertmapItemMode()
        
        Returns:
            state (int):
        """
        pass

    def VertmapType(self):
        """integer type = VertmapType()
        
        Returns:
            type (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class UIValueHints:
    """UIValueHints"""
    def __init__(self, unknown=None):
        pass

    def ColorPickerCommands(self, rgb, alpha, rgbAlt, alphaAlt, useAlt, bufLens):
        """ColorPickerCommands(byte[] rgb,byte[] alpha,byte[] rgbAlt,byte[] alphaAlt,byte[] useAlt,integer bufLens)
        
        Args:
            rgb (byte[]):
            alpha (byte[]):
            rgbAlt (byte[]):
            alphaAlt (byte[]):
            useAlt (byte[]):
            bufLens (int):

        Returns:
            None
        """
        pass

    def CueText(self):
        """string = CueText()
        
        Returns:
            str
        """
        pass

    def Flags(self):
        """integer = Flags()
        
        Returns:
            int
        """
        pass

    def FormCommandListByIndex(self, index):
        """string command = FormCommandListByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            command (str):
        """
        pass

    def FormCommandListCount(self):
        """integer count = FormCommandListCount()
        
        Returns:
            count (int):
        """
        pass

    def ItemTest(self, item):
        """boolean = ItemTest(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def NotifierByIndex(self, index):
        """(string name,string args) = NotifierByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            (string name,string args)
        """
        pass

    def NotifierCount(self):
        """integer count = NotifierCount()
        
        Returns:
            count (int):
        """
        pass

    def PopCategory(self):
        """string category = PopCategory()
        
        Returns:
            category (str):
        """
        pass

    def PopCount(self):
        """integer = PopCount()
        
        Returns:
            int
        """
        pass

    def PopFlags(self, index):
        """integer flags = PopFlags(integer index)
        
        Args:
            index (int):

        Returns:
            flags (int):
        """
        pass

    def PopIconImage(self, index):
        """Image object = PopIconImage(integer index)
        
        Args:
            index (int):

        Returns:
            object (lx.object.Image):
        """
        pass

    def PopIconResource(self, index):
        """string iconResource = PopIconResource(integer index)
        
        Args:
            index (int):

        Returns:
            iconResource (str):
        """
        pass

    def PopIconSize(self):
        """(integer,integer w,integer h) = PopIconSize()
        
        Returns:
            (integer,integer w,integer h)
        """
        pass

    def PopInternalName(self, index):
        """string = PopInternalName(integer index)
        
        Args:
            index (int):

        Returns:
            str
        """
        pass

    def PopToolTip(self, index):
        """string = PopToolTip(integer index)
        
        Args:
            index (int):

        Returns:
            str
        """
        pass

    def PopUserName(self, index):
        """string = PopUserName(integer index)
        
        Args:
            index (int):

        Returns:
            str
        """
        pass

    def TextValidate(self, value):
        """string = TextValidate(string value)
        
        Args:
            value (str):

        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Undo:
    """Undo"""
    def __init__(self, unknown=None):
        pass

    def Forward(self):
        """Forward()
        
        Returns:
            None
        """
        pass

    def Reverse(self):
        """Reverse()
        
        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Unknown:
    """Unknown"""
    def __init__(self, unknown=None):
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class UserValue:
    """UserValue"""
    def __init__(self, unknown=None):
        pass

    def Action(self):
        """string action = Action()
        
        Returns:
            action (str):
        """
        pass

    def ArgType(self):
        """string argType = ArgType()
        
        Returns:
            argType (str):
        """
        pass

    def AsUI(self):
        """boolean = AsUI()
        
        Returns:
            bool
        """
        pass

    def DefaultValue(self):
        """Unknown object = DefaultValue()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def DeferAction(self):
        """boolean = DeferAction()
        
        Returns:
            bool
        """
        pass

    def DialogUserName(self):
        """string username = DialogUserName()
        
        Returns:
            username (str):
        """
        pass

    def EnableCommand(self):
        """string command = EnableCommand()
        
        Returns:
            command (str):
        """
        pass

    def FloatRange(self):
        """(integer hasMin,float min,integer hasMax,float max) = FloatRange()
        
        Returns:
            (integer hasMin,float min,integer hasMax,float max)
        """
        pass

    def GetFlt(self):
        """float val = GetFlt()
        
        Returns:
            val (float):
        """
        pass

    def GetInt(self):
        """integer val = GetInt()
        
        Returns:
            val (int):
        """
        pass

    def GetString(self):
        """string = GetString()
        
        Returns:
            str
        """
        pass

    def IntRange(self):
        """(integer hasMin,integer min,integer hasMax,integer max) = IntRange()
        
        Returns:
            (integer hasMin,integer min,integer hasMax,integer max)
        """
        pass

    def InvertEnableCommandTest(self):
        """boolean = InvertEnableCommandTest()
        
        Returns:
            bool
        """
        pass

    def IsTransient(self):
        """(boolean,integer isTransient) = IsTransient()
        
        Returns:
            isTransient) ((boolean,integer):
        """
        pass

    def Lifespan(self):
        """integer life = Lifespan()
        
        Returns:
            life (int):
        """
        pass

    def List(self):
        """string list = List()
        
        Returns:
            list (str):
        """
        pass

    def ListNames(self):
        """string listNames = ListNames()
        
        Returns:
            listNames (str):
        """
        pass

    def Name(self):
        """string name = Name()
        
        Returns:
            name (str):
        """
        pass

    def Notifier(self):
        """string notifier = Notifier()
        
        Returns:
            notifier (str):
        """
        pass

    def Type(self):
        """integer type = Type()
        
        Returns:
            type (int):
        """
        pass

    def TypeName(self):
        """string tname = TypeName()
        
        Returns:
            tname (str):
        """
        pass

    def UIMode(self):
        """integer uiMode = UIMode()
        
        Returns:
            uiMode (int):
        """
        pass

    def UserName(self):
        """string username = UserName()
        
        Returns:
            username (str):
        """
        pass

    def ValuePresetCookie(self):
        """string cookie = ValuePresetCookie()
        
        Returns:
            cookie (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class UserValueListener:
    """UserValueListener"""
    def __init__(self, unknown=None):
        pass

    def Added(self, userValue):
        """Added(object userValue)
        
        Args:
            userValue (userValue):

        Returns:
            None
        """
        pass

    def DefChanged(self, userValue):
        """DefChanged(object userValue)
        
        Args:
            userValue (userValue):

        Returns:
            None
        """
        pass

    def Deleted(self, name):
        """Deleted(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass

    def ValueChanged(self, userValue):
        """ValueChanged(object userValue)
        
        Args:
            userValue (userValue):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VMapPacketTranslation:
    """VMapPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Name(self, packet):
        """string name = Name(pointer packet)
        
        Args:
            packet (int):

        Returns:
            name (str):
        """
        pass

    def Packet(self, type, name):
        """pointer = Packet(integer type,string name)
        
        Args:
            type (int):
            name (str):

        Returns:
            int
        """
        pass

    def Type(self, packet):
        """integer type = Type(pointer packet)
        
        Args:
            packet (int):

        Returns:
            type (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Value:
    """Value"""
    def __init__(self, unknown=None):
        pass

    def Clone(self):
        """Value object = Clone()
        
        Returns:
            object (Value):
        """
        pass

    def Compare(self, other):
        """integer diff = Compare(object other)
        
        Args:
            other (other):

        Returns:
            diff (int):
        """
        pass

    def Copy(self, from_obj):
        """Copy(object from_obj)
        
        Args:
            from_obj (from_obj):

        Returns:
            None
        """
        pass

    def GetFlt(self):
        """float val = GetFlt()
        
        Returns:
            val (float):
        """
        pass

    def GetInt(self):
        """integer val = GetInt()
        
        Returns:
            val (int):
        """
        pass

    def GetString(self):
        """string = GetString()
        
        Returns:
            str
        """
        pass

    def Intrinsic(self):
        """pointer = Intrinsic()
        
        Returns:
            int
        """
        pass

    def SetFlt(self, val):
        """SetFlt(float val)
        
        Args:
            val (float):

        Returns:
            None
        """
        pass

    def SetInt(self, val):
        """SetInt(integer val)
        
        Args:
            val (int):

        Returns:
            None
        """
        pass

    def SetString(self, val):
        """SetString(string val)
        
        Args:
            val (str):

        Returns:
            None
        """
        pass

    def SubTypeName(self):
        """string name = SubTypeName()
        
        Returns:
            name (str):
        """
        pass

    def Type(self):
        """integer = Type()
        
        Returns:
            int
        """
        pass

    def TypeName(self):
        """string name = TypeName()
        
        Returns:
            name (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ValueArray:
    """ValueArray"""
    def __init__(self, unknown=None):
        pass

    def AddEmptyValue(self):
        """Value object = AddEmptyValue()
        
        Returns:
            object (Value):
        """
        pass

    def AddFloat(self, value):
        """AddFloat(float value)
        
        Args:
            value (float):

        Returns:
            None
        """
        pass

    def AddInt(self, value):
        """AddInt(integer value)
        
        Args:
            value (int):

        Returns:
            None
        """
        pass

    def AddString(self, value):
        """AddString(string value)
        
        Args:
            value (str):

        Returns:
            None
        """
        pass

    def AddValue(self, value):
        """AddValue(object value)
        
        Args:
            value (value):

        Returns:
            None
        """
        pass

    def Count(self):
        """integer = Count()
        
        Returns:
            int
        """
        pass

    def FirstUnique(self):
        """integer uniqueIndex = FirstUnique()
        
        Returns:
            uniqueIndex (int):
        """
        pass

    def GetFloat(self, index):
        """float value = GetFloat(integer index)
        
        Args:
            index (int):

        Returns:
            value (float):
        """
        pass

    def GetInt(self, index):
        """integer value = GetInt(integer index)
        
        Args:
            index (int):

        Returns:
            value (int):
        """
        pass

    def GetString(self, index):
        """string = GetString(integer index)
        
        Args:
            index (int):

        Returns:
            str
        """
        pass

    def GetValue(self, index):
        """Value object = GetValue(integer index)
        
        Args:
            index (int):

        Returns:
            object (Value):
        """
        pass

    def Remove(self, index):
        """Remove(integer index)
        
        Args:
            index (int):

        Returns:
            None
        """
        pass

    def Reset(self):
        """Reset()
        
        Returns:
            None
        """
        pass

    def SetFloat(self, index, value):
        """SetFloat(integer index,float value)
        
        Args:
            index (int):
            value (float):

        Returns:
            None
        """
        pass

    def SetInt(self, index, value):
        """SetInt(integer index,integer value)
        
        Args:
            index (int):
            value (int):

        Returns:
            None
        """
        pass

    def SetString(self, index, value):
        """SetString(integer index,string value)
        
        Args:
            index (int):
            value (str):

        Returns:
            None
        """
        pass

    def SetValue(self, index, value):
        """SetValue(integer index,object value)
        
        Args:
            index (int):
            value (value):

        Returns:
            None
        """
        pass

    def Type(self):
        """integer type = Type()
        
        Returns:
            type (int):
        """
        pass

    def TypeName(self):
        """string name = TypeName()
        
        Returns:
            name (str):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ValueConversion:
    """ValueConversion"""
    def __init__(self, unknown=None):
        pass

    def Convert(self, from_obj, fromType, to_obj, toType):
        """Convert(object from_obj,string fromType,object to_obj,string toType)
        
        Args:
            from_obj (from_obj):
            fromType (str):
            to_obj (to_obj):
            toType (str):

        Returns:
            None
        """
        pass

    def Test(self, fromType, toType):
        """Test(string fromType,string toType)
        
        Args:
            fromType (str):
            toType (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ValueMath:
    """ValueMath"""
    def __init__(self, unknown=None):
        pass

    def Add(self, delta):
        """Add(float delta)
        
        Args:
            delta (float):

        Returns:
            None
        """
        pass

    def Blend(self, other, blend):
        """Blend(object other,float blend)
        
        Args:
            other (other):
            blend (float):

        Returns:
            None
        """
        pass

    def Detent(self):
        """integer = Detent()
        
        Returns:
            int
        """
        pass

    def Multiply(self, factor):
        """Multiply(float factor)
        
        Args:
            factor (float):

        Returns:
            None
        """
        pass

    def Step(self, direction):
        """Step(integer direction)
        
        Args:
            direction (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ValueReference:
    """ValueReference"""
    def __init__(self, unknown=None):
        pass

    def GetObject(self):
        """Unknown object = GetObject()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def IsSet(self):
        """boolean = IsSet()
        
        Returns:
            bool
        """
        pass

    def SetObject(self, obj):
        """SetObject(object obj)
        
        Args:
            obj (obj):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ValueTexture:
    """ValueTexture"""
    def __init__(self, unknown=None):
        pass

    def Cleanup(self, data):
        """Cleanup(pointer data)
        
        Args:
            data (int):

        Returns:
            None
        """
        pass

    def IsSampleDriven(self):
        """(integer,integer idx) = IsSampleDriven()
        
        Returns:
            idx) ((integer,integer):
        """
        pass

    def LinkChannels(self, eval, item):
        """LinkChannels(object eval,object item)
        
        Args:
            eval (eval):
            item (lxu.object.Item):

        Returns:
            None
        """
        pass

    def LinkSampleChannels(self, nodalEtor, item):
        """integer idx = LinkSampleChannels(object nodalEtor,object item)
        
        Args:
            nodalEtor (nodalEtor):
            item (lxu.object.Item):

        Returns:
            idx (int):
        """
        pass

    def Setup(self, data):
        """Setup(pointer data)
        
        Args:
            data (int):

        Returns:
            None
        """
        pass

    def SetupChannels(self, addChan):
        """SetupChannels(object addChan)
        
        Args:
            addChan (addChan):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ValueTextureCustom:
    """ValueTextureCustom"""
    def __init__(self, unknown=None):
        pass

    def AddFeature(self, type, name):
        """AddFeature(integer type,string name)
        
        Args:
            type (int):
            name (str):

        Returns:
            None
        """
        pass

    def AddPacket(self, name):
        """AddPacket(string name)
        
        Args:
            name (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Variation:
    """Variation"""
    def __init__(self, unknown=None):
        pass

    def Do(self, x, y):
        """Do(float x,float y)
        
        Args:
            x (float):
            y (float):

        Returns:
            None
        """
        pass

    def Initialize(self, item, chanRead):
        """(float x,float y) = Initialize(object item,object chanRead)
        
        Args:
            item (lxu.object.Item):
            chanRead (chanRead):

        Returns:
            (float x,float y)
        """
        pass

    def RangeX(self):
        """(float min,float max) = RangeX()
        
        Returns:
            (float min,float max)
        """
        pass

    def RangeY(self):
        """(float min,float max) = RangeY()
        
        Returns:
            (float min,float max)
        """
        pass

    def TestItem(self, item, chanRead):
        """boolean = TestItem(object item,object chanRead)
        
        Args:
            item (lxu.object.Item):
            chanRead (chanRead):

        Returns:
            bool
        """
        pass

    def Thumb(self, x, y, size, chanRead):
        """Unknown object = Thumb(float x,float y,integer size,object chanRead)
        
        Args:
            x (float):
            y (float):
            size (int):
            chanRead (chanRead):

        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorCanvas:
    """VectorCanvas"""
    def __init__(self, unknown=None):
        pass

    def BeginEditBatch(self):
        """BeginEditBatch()
        
        Returns:
            None
        """
        pass

    def EndEditBatch(self):
        """EndEditBatch()
        
        Returns:
            None
        """
        pass

    def GetItem(self):
        """Item object = GetItem()
        
        Returns:
            object (lxu.object.Item):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorKnotPacketTranslation:
    """VectorKnotPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Canvas(self, packet):
        """VectorCanvas object = Canvas(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorCanvas):
        """
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def Path(self, packet):
        """VectorPath object = Path(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorPath):
        """
        pass

    def Shape(self, packet):
        """VectorShape object = Shape(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorShape):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorList:
    """VectorList"""
    def __init__(self, unknown=None):
        pass

    def Append(self):
        """integer index = Append()
        
        Returns:
            index (int):
        """
        pass

    def Clear(self):
        """Clear()
        
        Returns:
            None
        """
        pass

    def Count(self):
        """integer = Count()
        
        Returns:
            int
        """
        pass

    def Current(self):
        """integer = Current()
        
        Returns:
            int
        """
        pass

    def Optional(self, offset):
        """pointer = Optional(integer offset)
        
        Args:
            offset (int):

        Returns:
            int
        """
        pass

    def SetCurrent(self, index):
        """SetCurrent(integer index)
        
        Args:
            index (int):

        Returns:
            None
        """
        pass

    def SetPacket(self, offset, pdat):
        """SetPacket(integer offset,pointer pdat)
        
        Args:
            offset (int):
            pdat (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorListener:
    """VectorListener"""
    def __init__(self, unknown=None):
        pass

    def Destroy(self):
        """Destroy()
        
        Returns:
            None
        """
        pass

    def KnotPosition(self, shape, path):
        """KnotPosition(object shape,object path)
        
        Args:
            shape (shape):
            path (path):

        Returns:
            None
        """
        pass

    def PathAdd(self, shape, path):
        """PathAdd(object shape,object path)
        
        Args:
            shape (shape):
            path (path):

        Returns:
            None
        """
        pass

    def PathRemove(self, shape, path):
        """PathRemove(object shape,object path)
        
        Args:
            shape (shape):
            path (path):

        Returns:
            None
        """
        pass

    def ShapeAdd(self, shape):
        """ShapeAdd(object shape)
        
        Args:
            shape (shape):

        Returns:
            None
        """
        pass

    def ShapeRemove(self, shape):
        """ShapeRemove(object shape)
        
        Args:
            shape (shape):

        Returns:
            None
        """
        pass

    def ShapeStyle(self, shape, name):
        """ShapeStyle(object shape,string name)
        
        Args:
            shape (shape):
            name (str):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorPath:
    """VectorPath"""
    def __init__(self, unknown=None):
        pass

    def ID(self):
        """id = ID()
        
        Returns:
            id
        """
        pass

    def IsPathClosed(self):
        """boolean = IsPathClosed()
        
        Returns:
            bool
        """
        pass

    def KnotCount(self):
        """integer count = KnotCount()
        
        Returns:
            count (int):
        """
        pass

    def KnotEnumerate(self, visitor):
        """KnotEnumerate(object visitor)
        
        Args:
            visitor (visitor):

        Returns:
            None
        """
        pass

    def Pos(self):
        """(float x,float y) = Pos()
        
        Returns:
            (float x,float y)
        """
        pass

    def SelectKnot(self, knot):
        """SelectKnot(id knot)
        
        Args:
            knot (id):

        Returns:
            None
        """
        pass

    def SelectKnotByIndex(self, index):
        """SelectKnotByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            None
        """
        pass

    def SetPathClosed(self, closed):
        """SetPathClosed(integer closed)
        
        Args:
            closed (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorPathPacketTranslation:
    """VectorPathPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Canvas(self, packet):
        """VectorCanvas object = Canvas(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorCanvas):
        """
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def Packet(self, path):
        """pointer = Packet(object path)
        
        Args:
            path (path):

        Returns:
            int
        """
        pass

    def Path(self, packet):
        """VectorPath object = Path(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorPath):
        """
        pass

    def Shape(self, packet):
        """VectorShape object = Shape(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorShape):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorShape:
    """VectorShape"""
    def __init__(self, unknown=None):
        pass

    def Parent(self):
        """VectorShape object = Parent()
        
        Returns:
            object (VectorShape):
        """
        pass

    def PathByIndex(self, index):
        """VectorPath object = PathByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (VectorPath):
        """
        pass

    def PathCount(self):
        """integer count = PathCount()
        
        Returns:
            count (int):
        """
        pass

    def ShapeByIndex(self, index):
        """VectorShape object = ShapeByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            object (VectorShape):
        """
        pass

    def ShapeCount(self):
        """integer count = ShapeCount()
        
        Returns:
            count (int):
        """
        pass

    def Transform(self, matrix):
        """Transform(matrix matrix)
        
        Args:
            matrix (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorShapePacketTranslation:
    """VectorShapePacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Canvas(self, packet):
        """VectorCanvas object = Canvas(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorCanvas):
        """
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def Packet(self, shape):
        """pointer = Packet(object shape)
        
        Args:
            shape (shape):

        Returns:
            int
        """
        pass

    def Shape(self, packet):
        """VectorShape object = Shape(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (VectorShape):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorStack:
    """VectorStack"""
    def __init__(self, unknown=None):
        pass

    def Optional(self, offset):
        """pointer = Optional(integer offset)
        
        Args:
            offset (int):

        Returns:
            int
        """
        pass

    def Pop(self):
        """Pop()
        
        Returns:
            None
        """
        pass

    def Push(self):
        """Push()
        
        Returns:
            None
        """
        pass

    def SetPacket(self, offset, pdat):
        """SetPacket(integer offset,pointer pdat)
        
        Args:
            offset (int):
            pdat (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VectorType:
    """VectorType"""
    def __init__(self, unknown=None):
        pass

    def ByIndex(self, type, index):
        """(integer,integer flags) = ByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            flags) ((integer,integer):
        """
        pass

    def Category(self):
        """string = Category()
        
        Returns:
            str
        """
        pass

    def Count(self, type):
        """integer = Count(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def Test(self, offset):
        """integer = Test(integer offset)
        
        Args:
            offset (int):

        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VertexPacketTranslation:
    """VertexPacketTranslation"""
    def __init__(self, unknown=None):
        pass

    def Item(self, packet):
        """Item object = Item(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (lxu.object.Item):
        """
        pass

    def Mesh(self, packet):
        """Mesh object = Mesh(pointer packet)
        
        Args:
            packet (int):

        Returns:
            object (lxu.object.Mesh):
        """
        pass

    def Packet(self, vertex, polygon, mesh):
        """pointer = Packet(id vertex,id polygon,object mesh)
        
        Args:
            vertex (id):
            polygon (id):
            mesh (lxu.object.Mesh):

        Returns:
            int
        """
        pass

    def Polygon(self, packet):
        """id polygon = Polygon(pointer packet)
        
        Args:
            packet (int):

        Returns:
            polygon (id):
        """
        pass

    def Vertex(self, packet):
        """id vertex = Vertex(pointer packet)
        
        Args:
            packet (int):

        Returns:
            vertex (id):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VideoClipItem:
    """VideoClipItem"""
    def __init__(self, unknown=None):
        pass

    def AllocFilter(self, attr, cache):
        """ImageFilter object = AllocFilter(object attr,pointer cache)
        
        Args:
            attr (attr):
            cache (int):

        Returns:
            object (ImageFilter):
        """
        pass

    def Cleanup(self, cache):
        """Cleanup(pointer cache)
        
        Args:
            cache (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class View:
    """View"""
    def __init__(self, unknown=None):
        pass

    def Aspect(self):
        """float = Aspect()
        
        Returns:
            float
        """
        pass

    def Axis(self):
        """integer = Axis()
        
        Returns:
            int
        """
        pass

    def Center(self):
        """vector center = Center()
        
        Returns:
            center (tuple):
        """
        pass

    def Dimensions(self):
        """(integer w,integer h) = Dimensions()
        
        Returns:
            (integer w,integer h)
        """
        pass

    def EyeVector(self, pos):
        """(float,vector eye) = EyeVector(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            eye) ((float,vector):
        """
        pass

    def Focal(self):
        """(float flen,float fdist) = Focal()
        
        Returns:
            (float flen,float fdist)
        """
        pass

    def GridSize(self):
        """float = GridSize()
        
        Returns:
            float
        """
        pass

    def GridSnap(self):
        """float = GridSnap()
        
        Returns:
            float
        """
        pass

    def InvMatrix(self):
        """matrix xfrm = InvMatrix()
        
        Returns:
            xfrm (lx.object.Matrix):
        """
        pass

    def Matrix(self):
        """matrix xfrm = Matrix()
        
        Returns:
            xfrm (lx.object.Matrix):
        """
        pass

    def Ortho(self):
        """(integer index,integer spin) = Ortho()
        
        Returns:
            (integer index,integer spin)
        """
        pass

    def PixelScale(self):
        """float = PixelScale()
        
        Returns:
            float
        """
        pass

    def Scale(self):
        """float = Scale()
        
        Returns:
            float
        """
        pass

    def ScreenNormals(self, pos):
        """(vector ax,vector ay,vector az) = ScreenNormals(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            (vector ax,vector ay,vector az)
        """
        pass

    def ToModel(self, x, y, snap):
        """vector pos = ToModel(integer x,integer y,integer snap)
        
        Args:
            x (int):
            y (int):
            snap (int):

        Returns:
            pos (tuple):
        """
        pass

    def ToScreen(self, pos):
        """(integer,float x,float y) = ToScreen(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            (integer,float x,float y)
        """
        pass

    def ToScreen3(self, pos):
        """(integer,vector vp) = ToScreen3(vector pos)
        
        Args:
            pos (tuple):

        Returns:
            vp) ((integer,vector):
        """
        pass

    def Type(self):
        """integer = Type()
        
        Returns:
            int
        """
        pass

    def WorkPlane(self):
        """(integer,vector center) = WorkPlane()
        
        Returns:
            center) ((integer,vector):
        """
        pass

    def Zoom(self):
        """float = Zoom()
        
        Returns:
            float
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class View3D:
    """View3D"""
    def __init__(self, unknown=None):
        pass

    def Angles(self):
        """vector hpb = Angles()
        
        Returns:
            hpb (tuple):
        """
        pass

    def Axis(self):
        """(integer,integer cam,vector axis) = Axis()
        
        Returns:
            (integer,integer cam,vector axis)
        """
        pass

    def BackdropAspect(self):
        """(integer,float asp) = BackdropAspect()
        
        Returns:
            asp) ((integer,float):
        """
        pass

    def BackdropLook(self):
        """(integer,float brit,float cont,float trns) = BackdropLook()
        
        Returns:
            (integer,float brit,float cont,float trns)
        """
        pass

    def BackdropName(self):
        """string = BackdropName()
        
        Returns:
            str
        """
        pass

    def BackdropOrient(self):
        """(integer,float ang) = BackdropOrient()
        
        Returns:
            ang) ((integer,float):
        """
        pass

    def BackdropPlace(self):
        """(float cx,float cy,float w,float h) = BackdropPlace()
        
        Returns:
            (float cx,float cy,float w,float h)
        """
        pass

    def BackdropRender(self):
        """(integer,integer resolution,integer blend) = BackdropRender()
        
        Returns:
            (integer,integer resolution,integer blend)
        """
        pass

    def Bounds(self):
        """(integer x,integer y,integer w,integer h) = Bounds()
        
        Returns:
            (integer x,integer y,integer w,integer h)
        """
        pass

    def Center(self):
        """vector center = Center()
        
        Returns:
            center (tuple):
        """
        pass

    def Deformers(self):
        """Deformers()
        
        Returns:
            None
        """
        pass

    def EyeVector(self):
        """(float,vector pos,vector dir) = EyeVector()
        
        Returns:
            (float,vector pos,vector dir)
        """
        pass

    def FrameRate(self):
        """float = FrameRate()
        
        Returns:
            float
        """
        pass

    def GridSize(self):
        """float = GridSize()
        
        Returns:
            float
        """
        pass

    def InvalidateSurface(self, item):
        """InvalidateSurface(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            None
        """
        pass

    def ItemIsVisible(self, item):
        """ItemIsVisible(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            None
        """
        pass

    def ItemShade(self, item):
        """integer shade = ItemShade(object item)
        
        Args:
            item (lxu.object.Item):

        Returns:
            shade (int):
        """
        pass

    def Matrix(self, inverse):
        """matrix mat = Matrix(integer inverse)
        
        Args:
            inverse (int):

        Returns:
            mat (lx.object.Matrix):
        """
        pass

    def PixelSize(self):
        """float = PixelSize()
        
        Returns:
            float
        """
        pass

    def SetCenter(self, vec):
        """SetCenter(vector vec)
        
        Args:
            vec (tuple):

        Returns:
            None
        """
        pass

    def SetMatrix(self, mat):
        """SetMatrix(matrix mat)
        
        Args:
            mat (lx.object.Matrix):

        Returns:
            None
        """
        pass

    def SetScale(self, scl):
        """SetScale(float scl)
        
        Args:
            scl (float):

        Returns:
            None
        """
        pass

    def Space(self):
        """integer = Space()
        
        Returns:
            int
        """
        pass

    def Style(self, option):
        """integer = Style(integer option)
        
        Args:
            option (int):

        Returns:
            int
        """
        pass

    def To3D(self, x, y, flags):
        """vector pos = To3D(float x,float y,integer flags)
        
        Args:
            x (float):
            y (float):
            flags (int):

        Returns:
            pos (tuple):
        """
        pass

    def To3DHit(self, x, y):
        """(vector pos,vector nrm) = To3DHit(float x,float y)
        
        Args:
            x (float):
            y (float):

        Returns:
            (vector pos,vector nrm)
        """
        pass

    def ToUVHit(self, name, x, y, layer):
        """(float u,float v) = ToUVHit(string name,float x,float y,integer layer)
        
        Args:
            name (str):
            x (float):
            y (float):
            layer (int):

        Returns:
            (float u,float v)
        """
        pass

    def WorkPlane(self):
        """(integer,vector center) = WorkPlane()
        
        Returns:
            center) ((integer,vector):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ViewItem3D:
    """ViewItem3D"""
    def __init__(self, unknown=None):
        pass

    def Draw(self, chanRead, strokeDraw, selectionFlags, itemColor):
        """Draw(object chanRead,object strokeDraw,integer selectionFlags,vector itemColor)
        
        Args:
            chanRead (chanRead):
            strokeDraw (strokeDraw):
            selectionFlags (int):
            itemColor (tuple):

        Returns:
            None
        """
        pass

    def DrawBackground(self, chanRead, strokeDraw, itemColor):
        """DrawBackground(object chanRead,object strokeDraw,vector itemColor)
        
        Args:
            chanRead (chanRead):
            strokeDraw (strokeDraw):
            itemColor (tuple):

        Returns:
            None
        """
        pass

    def HandleChannel(self, handleIndex):
        """integer chanIndex = HandleChannel(integer handleIndex)
        
        Args:
            handleIndex (int):

        Returns:
            chanIndex (int):
        """
        pass

    def HandleCount(self):
        """integer count = HandleCount()
        
        Returns:
            count (int):
        """
        pass

    def HandleMotion(self, handleIndex):
        """(integer handleFlags,float min,float max,vector plane,vector offset) = HandleMotion(integer handleIndex)
        
        Args:
            handleIndex (int):

        Returns:
            (integer handleFlags,float min,float max,vector plane,vector offset)
        """
        pass

    def HandlePositionToValue(self, handleIndex, position):
        """float chanValue = HandlePositionToValue(integer handleIndex,vector position)
        
        Args:
            handleIndex (int):
            position (tuple):

        Returns:
            chanValue (float):
        """
        pass

    def HandleValueToPosition(self, handleIndex, chanValue):
        """vector position = HandleValueToPosition(integer handleIndex,double[] chanValue)
        
        Args:
            handleIndex (int):
            chanValue (double[]):

        Returns:
            position (tuple):
        """
        pass

    def Test(self, chanRead, strokeDraw, selectionFlags, itemColor):
        """Test(object chanRead,object strokeDraw,integer selectionFlags,vector itemColor)
        
        Args:
            chanRead (chanRead):
            strokeDraw (strokeDraw):
            selectionFlags (int):
            itemColor (tuple):

        Returns:
            None
        """
        pass

    def WorldSpace(self):
        """boolean = WorldSpace()
        
        Returns:
            bool
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class ViewObject:
    """ViewObject"""
    def __init__(self, unknown=None):
        pass

    def ByIndex(self, type, index):
        """ViewObject object = ByIndex(integer type,integer index)
        
        Args:
            type (int):
            index (int):

        Returns:
            object (ViewObject):
        """
        pass

    def ByView(self, view):
        """ViewObject object = ByView(object view)
        
        Args:
            view (view):

        Returns:
            object (ViewObject):
        """
        pass

    def Count(self, type):
        """integer = Count(integer type)
        
        Args:
            type (int):

        Returns:
            int
        """
        pass

    def Flags(self):
        """integer = Flags()
        
        Returns:
            int
        """
        pass

    def Generate(self, type):
        """Generate(integer type)
        
        Args:
            type (int):

        Returns:
            None
        """
        pass

    def TestMode(self, type):
        """TestMode(integer type)
        
        Args:
            type (int):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VirtualDevice:
    """VirtualDevice"""
    def __init__(self, unknown=None):
        pass

    def Date(self):
        """string = Date()
        
        Returns:
            str
        """
        pass

    def Extract(self, dest):
        """Extract(string dest)
        
        Args:
            dest (str):

        Returns:
            None
        """
        pass

    def Initialize(self, path):
        """Initialize(string path)
        
        Args:
            path (str):

        Returns:
            None
        """
        pass

    def Name(self):
        """string = Name()
        
        Returns:
            str
        """
        pass

    def Scan(self, visitor):
        """Scan(object visitor)
        
        Args:
            visitor (visitor):

        Returns:
            None
        """
        pass

    def Select(self, sub):
        """Select(string sub)
        
        Args:
            sub (str):

        Returns:
            None
        """
        pass

    def Size(self):
        """float bytes = Size()
        
        Returns:
            bytes (float):
        """
        pass

    def Type(self):
        """integer type = Type()
        
        Returns:
            type (int):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class VirtualModel:
    """VirtualModel"""
    def __init__(self, unknown=None):
        pass

    def Down(self, vts):
        """Down(object vts)
        
        Args:
            vts (vts):

        Returns:
            None
        """
        pass

    def Draw(self, stroke):
        """Draw(object stroke)
        
        Args:
            stroke (stroke):

        Returns:
            None
        """
        pass

    def Flags(self):
        """integer = Flags()
        
        Returns:
            int
        """
        pass

    def Move(self, vts):
        """Move(object vts)
        
        Args:
            vts (vts):

        Returns:
            None
        """
        pass

    def Test(self, stroke):
        """Test(object stroke)
        
        Args:
            stroke (stroke):

        Returns:
            None
        """
        pass

    def Tooltip(self, part):
        """string = Tooltip(integer part)
        
        Args:
            part (int):

        Returns:
            str
        """
        pass

    def Track(self, part):
        """Track(integer part)
        
        Args:
            part (int):

        Returns:
            None
        """
        pass

    def Up(self, vts):
        """Up(object vts)
        
        Args:
            vts (vts):

        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Visitor:
    """Visitor"""
    def __init__(self, unknown=None):
        pass

    def Evaluate(self):
        """Evaluate()
        
        Returns:
            None
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Voxel:
    """Voxel"""
    def __init__(self, unknown=None):
        pass

    def BBox(self):
        """bounds bbox = BBox()
        
        Returns:
            bbox (bounds):
        """
        pass

    def FeatureByIndex(self, index):
        """string name = FeatureByIndex(integer index)
        
        Args:
            index (int):

        Returns:
            name (str):
        """
        pass

    def FeatureCount(self):
        """integer num = FeatureCount()
        
        Returns:
            num (int):
        """
        pass

    def NextPos(self, currentPos, currentSegment, stride):
        """(float segmentList,integer nextSegment,float nextPos) = NextPos(float currentPos,integer currentSegment,float stride)
        
        Args:
            currentPos (float):
            currentSegment (int):
            stride (float):

        Returns:
            (float segmentList,integer nextSegment,float nextPos)
        """
        pass

    def Sample(self, pos, index):
        """float val = Sample(vector pos,integer index)
        
        Args:
            pos (tuple):
            index (int):

        Returns:
            val (float):
        """
        pass

    def VDBData(self):
        """Unknown object = VDBData()
        
        Returns:
            object (lxu.object.Unknown):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class Waterfall:
    """Waterfall"""
    def __init__(self, unknown=None):
        pass

    def Advance(self):
        """Advance()
        
        Returns:
            None
        """
        pass

    def GetWork(self):
        """GetWork()
        
        Returns:
            None
        """
        pass

    def ProcessWork(self):
        """ProcessWork()
        
        Returns:
            None
        """
        pass

    def Spawn(self):
        """Waterfall object = Spawn()
        
        Returns:
            object (Waterfall):
        """
        pass

    def State(self):
        """integer = State()
        
        Returns:
            int
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class WeightMapDeformerItem:
    """WeightMapDeformerItem"""
    def __init__(self, unknown=None):
        pass

    def GetColor(self, chanRead):
        """vector col = GetColor(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            col (tuple):
        """
        pass

    def GetMapName(self, chanRead):
        """string = GetMapName(object chanRead)
        
        Args:
            chanRead (chanRead):

        Returns:
            str
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class WorkList:
    """WorkList"""
    def __init__(self, unknown=None):
        pass

    def Clear(self):
        """Clear()
        
        Returns:
            None
        """
        pass

    def IsEmpty(self):
        """boolean = IsEmpty()
        
        Returns:
            bool
        """
        pass

    def Next(self):
        """pointer = Next()
        
        Returns:
            int
        """
        pass

    def Split(self, mode):
        """WorkList object = Split(integer mode)
        
        Args:
            mode (int):

        Returns:
            object (WorkList):
        """
        pass

    def set(self, source):
        """bool = set(object source)
        
        Args:
            source (lxu.object.Item):

        Returns:
            bool
        """
        pass

    def test(self):
        """bool = test()
        
        Returns:
            bool
        """
        pass


class storage:
    """Storage objects"""
    def __init__(self, unknown=None):
        pass

    def get(self):
        """Read out the contents of the buffer as a tuple, either the full length or the specified length
        
        Returns:
            None
        """
        pass

    def offset(self):
        """Set or read the offset in the buffer
        
        Returns:
            None
        """
        pass

    def set(self):
        """Assign a tuple to fill the buffer
        
        Returns:
            None
        """
        pass

    def setSize(self):
        """Set the number of elements in the buffer
        
        Returns:
            None
        """
        pass

    def setType(self):
        """Set the element type for buffer: float, double, int, byte, unsigned, pointer
        
        Returns:
            None
        """
        pass

    def size(self):
        """Return the size of the buffer
        
        Returns:
            None
        """
        pass

    def string(self):
        """Read out the contents of the buffer as a string
        
        Returns:
            None
        """
        pass
