from __future__ import annotations
import pxr.Tf._tf
import typing
import Boost.Python
import pxr.Tf
import python

__all__ = [
    "CallContext",
    "CppException",
    "Debug",
    "DiagnosticType",
    "DictionaryStrcmp",
    "DumpTokenStats",
    "Enum",
    "Error",
    "FindLongestAccessiblePrefix",
    "GetAppLaunchTime",
    "GetCurrentScopeDescriptionStack",
    "GetEnvSetting",
    "GetStackTrace",
    "InstallTerminateAndCrashHandlers",
    "InvokeWithErrorHandling",
    "IsValidIdentifier",
    "LogStackTrace",
    "MakeValidIdentifier",
    "MallocTag",
    "Notice",
    "PrintStackTrace",
    "PyModuleWasLoaded",
    "RealPath",
    "RefPtrTracker",
    "ReportActiveErrorMarks",
    "RepostErrors",
    "ScopeDescription",
    "ScriptModuleLoader",
    "SetPythonExceptionDebugTracingEnabled",
    "Singleton",
    "StatusObject",
    "Stopwatch",
    "StringSplit",
    "StringToDouble",
    "StringToLong",
    "StringToULong",
    "TF_APPLICATION_EXIT_TYPE",
    "TF_DIAGNOSTIC_CODING_ERROR_TYPE",
    "TF_DIAGNOSTIC_FATAL_CODING_ERROR_TYPE",
    "TF_DIAGNOSTIC_FATAL_ERROR_TYPE",
    "TF_DIAGNOSTIC_NONFATAL_ERROR_TYPE",
    "TF_DIAGNOSTIC_RUNTIME_ERROR_TYPE",
    "TF_DIAGNOSTIC_STATUS_TYPE",
    "TF_DIAGNOSTIC_WARNING_TYPE",
    "TemplateString",
    "Tf_PyEnumWrapper",
    "Tf_TestAnnotatedBoolResult",
    "Tf_TestPyContainerConversions",
    "Tf_TestPyOptional",
    "TouchFile",
    "Type",
    "Warning"
]


class CallContext(Boost.Python.instance):
    @property
    def file(self) -> None:
        """
        type : char

        :type: None
        """
    @property
    def function(self) -> None:
        """
        type : char

        :type: None
        """
    @property
    def line(self) -> None:
        """
        type : int

        :type: None
        """
    @property
    def prettyFunction(self) -> None:
        """
        type : char

        :type: None
        """
    pass
class CppException(Exception, BaseException):
    pass
class Debug(Boost.Python.instance):
    @staticmethod
    def GetDebugSymbolDescription(*args, **kwargs) -> None: 
        """
        **classmethod** GetDebugSymbolDescription(name) -> str


        Get a description for the specified debug symbol.


        A short description of the debug symbol is returned. This is the same
        description string that is embedded in the return value of
        GetDebugSymbolDescriptions.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def GetDebugSymbolDescriptions(*args, **kwargs) -> None: 
        """
        **classmethod** GetDebugSymbolDescriptions() -> str


        Get a description of all debug symbols and their purpose.


        A single string describing all registered debug symbols along with
        short descriptions is returned.
        """
    @staticmethod
    def GetDebugSymbolNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetDebugSymbolNames() -> list[str]


        Get a listing of all debug symbols.
        """
    @staticmethod
    def IsDebugSymbolNameEnabled(*args, **kwargs) -> None: 
        """
        **classmethod** IsDebugSymbolNameEnabled(name) -> bool


        True if the specified debug symbol is set.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def SetDebugSymbolsByName(*args, **kwargs) -> None: 
        """
        **classmethod** SetDebugSymbolsByName(pattern, value) -> list[str]


        Set registered debug symbols matching ``pattern`` to ``value`` .


        All registered debug symbols matching ``pattern`` are set to ``value``
        . The only matching is an exact match with ``pattern`` , or if
        ``pattern`` ends with an'\*'as is otherwise a prefix of a debug
        symbols. The names of all debug symbols set by this call are returned
        as a vector.


        Parameters
        ----------
        pattern : str

        value : bool
        """
    @staticmethod
    def SetOutputFile(*args, **kwargs) -> None: 
        """
        **classmethod** SetOutputFile(file) -> None


        Direct debug output to *either* stdout or stderr.


        Note that *file* MUST be either stdout or stderr. If not, issue an
        error and do nothing. Debug output is issued to stdout by default. If
        the environment variable TF_DEBUG_OUTPUT_FILE is set to'stderr', then
        output is issued to stderr by default.


        Parameters
        ----------
        file : FILE
        """
    pass
class DiagnosticType(Tf_PyEnumWrapper, Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Tf.TF_DIAGNOSTIC_CODING_ERROR_TYPE, Tf.TF_DIAGNOSTIC_FATAL_CODING_ERROR_TYPE, Tf.TF_DIAGNOSTIC_RUNTIME_ERROR_TYPE, Tf.TF_DIAGNOSTIC_FATAL_ERROR_TYPE, Tf.TF_DIAGNOSTIC_NONFATAL_ERROR_TYPE, Tf.TF_DIAGNOSTIC_WARNING_TYPE, Tf.TF_DIAGNOSTIC_STATUS_TYPE, Tf.TF_APPLICATION_EXIT_TYPE)
    pass
class Enum(Boost.Python.instance):
    @staticmethod
    def GetValueFromFullName(*args, **kwargs) -> None: 
        """
        **classmethod** GetValueFromFullName(fullname, foundIt) -> Enum


        Returns the enumerated value for a fully-qualified name.


        This takes a fully-qualified enumerated value name (e.g.,
        ``"Season::WINTER"`` ) and returns the associated value. If there is
        no such name, this returns -1. Since -1 can sometimes be a valid
        value, the ``foundIt`` flag pointer, if not ``None`` , is set to
        ``true`` if the name was found and ``false`` otherwise. Also, since
        this is not a templated function, it has to return a generic value
        type, so we use ``TfEnum`` .


        Parameters
        ----------
        fullname : str

        foundIt : bool
        """
    pass
class Error(_DiagnosticBase, Boost.Python.instance):
    class Mark(Boost.Python.instance):
        @staticmethod
        def Clear(*args, **kwargs) -> None: ...
        @staticmethod
        def GetErrors(*args, **kwargs) -> None: 
            """
            A list of the errors held by this mark.
            """
        @staticmethod
        def IsClean(*args, **kwargs) -> None: ...
        @staticmethod
        def SetMark(*args, **kwargs) -> None: ...
        __instance_size__ = 24
        pass
    @property
    def errorCode(self) -> None:
        """
        The error code posted for this error.

        :type: None
        """
    @property
    def errorCodeString(self) -> None:
        """
        The error code posted for this error, as a string.

        :type: None
        """
    pass
class MallocTag(Boost.Python.instance):
    class CallTree(Boost.Python.instance):
        class CallSite(Boost.Python.instance):
            @property
            def nBytes(self) -> None:
                """
                :type: None
                """
            @property
            def name(self) -> None:
                """
                :type: None
                """
            pass
        class PathNode(Boost.Python.instance):
            @staticmethod
            def GetChildren(*args, **kwargs) -> None: ...
            @property
            def nAllocations(self) -> None:
                """
                :type: None
                """
            @property
            def nBytes(self) -> None:
                """
                :type: None
                """
            @property
            def nBytesDirect(self) -> None:
                """
                :type: None
                """
            @property
            def siteName(self) -> None:
                """
                :type: None
                """
            pass
        @staticmethod
        def GetCallSites(*args, **kwargs) -> None: ...
        @staticmethod
        def GetPrettyPrintString(*args, **kwargs) -> None: ...
        @staticmethod
        def GetRoot(*args, **kwargs) -> None: ...
        @staticmethod
        def LogReport(*args, **kwargs) -> None: ...
        @staticmethod
        def Report(*args, **kwargs) -> None: ...
        pass
    @staticmethod
    def GetCallStacks(*args, **kwargs) -> None: ...
    @staticmethod
    def GetCallTree(*args, **kwargs) -> None: 
        """
        **classmethod** GetCallTree(tree, skipRepeated) -> bool


        Return a snapshot of memory usage.


        Returns a snapshot by writing into ``\*tree`` . See the ``C`` \*tree
        structure for documentation. If ``Initialize()`` has not been called,
        \ \*tree is set to a rather blank structure (empty vectors, empty
        strings, zero in all integral fields) and ``false`` is returned;
        otherwise, ``\*tree`` is set with the contents of the current memory
        snapshot and ``true`` is returned. It is fine to call this function on
        the same ``\*tree`` instance; each call simply overwrites the data
        from the last call. If /p skipRepeated is ``true`` , then any repeated
        callsite is skipped. See the ``CallTree`` documentation for more
        details.


        Parameters
        ----------
        tree : CallTree

        skipRepeated : bool
        """
    @staticmethod
    def GetMaxTotalBytes(*args, **kwargs) -> None: 
        """
        **classmethod** GetMaxTotalBytes() -> int


        Return the maximum total number of bytes that have ever been allocated
        at one time.


        This is simply the maximum value of GetTotalBytes() since Initialize()
        was called.
        """
    @staticmethod
    def GetTotalBytes(*args, **kwargs) -> None: 
        """
        **classmethod** GetTotalBytes() -> int


        Return total number of allocated bytes.


        The current total memory that has been allocated and not freed is
        returned. Memory allocated before calling ``Initialize()`` is not
        accounted for.
        """
    @staticmethod
    def Initialize(*args, **kwargs) -> None: 
        """
        **classmethod** Initialize(errMsg) -> bool


        Initialize the memory tagging system.


        This function returns ``true`` if the memory tagging system can be
        successfully initialized or it has already been initialized.
        Otherwise, ``\*errMsg`` is set with an explanation for the failure.

        Until the system is initialized, the various memory reporting calls
        will indicate that no memory has been allocated. Note also that memory
        allocated prior to calling ``Initialize()`` is not tracked i.e. all
        data refers to allocations that happen subsequent to calling
        ``Initialize()`` .


        Parameters
        ----------
        errMsg : str
        """
    @staticmethod
    def IsInitialized(*args, **kwargs) -> None: 
        """
        **classmethod** IsInitialized() -> bool


        Return true if the tagging system is active.


        If ``Initialize()`` has been successfully called, this function
        returns ``true`` .
        """
    @staticmethod
    def SetCapturedMallocStacksMatchList(*args, **kwargs) -> None: 
        """
        **classmethod** SetCapturedMallocStacksMatchList(matchList) -> None


        Sets the tags to trace.


        When memory is allocated for any tag that matches ``matchList`` a
        stack trace is recorded. When that memory is released the stack trace
        is discarded. Clients can call ``GetCapturedMallocStacks()`` to get a
        list of all recorded stack traces. This is useful for finding leaks.

        Traces recorded for any tag that will no longer be matched are
        discarded by this call. Traces recorded for tags that continue to be
        matched are retained.

        ``matchList`` is a comma, tab or newline separated list of malloc tag
        names. The names can have internal spaces but leading and trailing
        spaces are stripped. If a name ends in'\*'then the suffix is
        wildcarded. A name can have a leading'-'or'+'to prevent or allow a
        match. Each name is considered in order and later matches override
        earlier matches. For example,'Csd\*, -CsdScene::_Populate\*,
        +CsdScene::_PopulatePrimCacheLocal'matches any malloc tag starting
        with'Csd'but nothing starting
        with'CsdScene::_Populate'except'CsdScene::_PopulatePrimCacheLocal'.
        Use the empty string to disable stack capturing.


        Parameters
        ----------
        matchList : str
        """
    @staticmethod
    def SetDebugMatchList(*args, **kwargs) -> None: 
        """
        **classmethod** SetDebugMatchList(matchList) -> None


        Sets the tags to trap in the debugger.


        When memory is allocated or freed for any tag that matches
        ``matchList`` the debugger trap is invoked. If a debugger is attached
        the program will stop in the debugger, otherwise the program will
        continue to run. See ``ArchDebuggerTrap()`` and ``ArchDebuggerWait()``
        .

        ``matchList`` is a comma, tab or newline separated list of malloc tag
        names. The names can have internal spaces but leading and trailing
        spaces are stripped. If a name ends in'\*'then the suffix is
        wildcarded. A name can have a leading'-'or'+'to prevent or allow a
        match. Each name is considered in order and later matches override
        earlier matches. For example,'Csd\*, -CsdScene::_Populate\*,
        +CsdScene::_PopulatePrimCacheLocal'matches any malloc tag starting
        with'Csd'but nothing starting
        with'CsdScene::_Populate'except'CsdScene::_PopulatePrimCacheLocal'.
        Use the empty string to disable debugging traps.


        Parameters
        ----------
        matchList : str
        """
    pass
class PyModuleWasLoaded(Notice, Boost.Python.instance):
    """
    A *TfNotice* that is sent when a script module is loaded. Since many
    modules may be loaded at once, listeners are encouraged to defer work
    triggered by this notice to the end of an application iteration. This,
    of course, is good practice in general.
    """
    @staticmethod
    def name() -> str: 
        """
        name() -> str


        Return the name of the module that was loaded.
        """
    pass
class Notice(Boost.Python.instance):
    class Listener(Boost.Python.instance):
        """
        Represents the Notice connection between senders and receivers of notices.  When a Listener object expires the connection is broken. You can also use the Revoke() function to break the connection. A Listener object is returned from the Register() and  RegisterGlobally() functions. 
        """
        @staticmethod
        def Revoke(*args, **kwargs) -> None: 
            """
            Revoke interest by a notice listener.  This function revokes interest in the particular notice type and call-back method that its Listener object was registered for. 
            """
        pass
    @staticmethod
    def Register( noticeType, callback, sender ) -> Listener : 
        """
        noticeType : Tf.Notice
        callback : function
        sender : object

        Register a listener as being interested in a TfNotice  type from a specific sender.  Notice listener will get sender  as an argument.     Registration of interest in a notice class N automatically  registers interest in all classes derived from N.  When a  notice of appropriate type is received, the listening object's  member-function method is called with the notice.     To reverse the registration, call Revoke() on the Listener object returned by this call. 

        noticeType : Tf.Notice
        callback : function
        sender : object

        Register a listener as being interested in a TfNotice  type from a specific sender.  Notice listener will get sender  as an argument.     Registration of interest in a notice class N automatically  registers interest in all classes derived from N.  When a  notice of appropriate type is received, the listening object's  member-function method is called with the notice.     To reverse the registration, call Revoke() on the Listener object returned by this call. 
        """
    @staticmethod
    def RegisterGlobally( noticeType, callback ) -> Listener : 
        """
        noticeType : Tf.Notice
        callback : function

        Register a listener as being interested in a TfNotice type from any sender.  The notice listener does not get sender as an argument. 
        """
    @staticmethod
    def Send(*args, **kwargs) -> None: 
        """
        sender : object 

        Deliver the notice to interested listeners, returning the number of interested listeners. This is the recommended form of Send.  It takes the sender as an argument. Listeners that registered for the given sender AND listeners that registered globally will get the notice. 

        sender : object 

        Deliver the notice to interested listeners, returning the number of interested listeners. This is the recommended form of Send.  It takes the sender as an argument. Listeners that registered for the given sender AND listeners that registered globally will get the notice. 
        """
    @staticmethod
    def SendGlobally(*args, **kwargs) -> None: 
        """
        Deliver the notice to interested listeners.   For most clients it is recommended to use the Send(sender) version of Send() rather than this one.  Clients that use this form of Send will prevent listeners from being able to register to receive notices based on the sender of the notice. ONLY listeners that registered globally will get the notice. 
        """
    pass
class RefPtrTracker(Boost.Python.instance):
    """
    Provides tracking of ``TfRefPtr`` objects to particular objects.

    Clients can enable, at compile time, tracking of ``TfRefPtr`` objects
    that point to particular instances of classes derived from
    ``TfRefBase`` . This is useful if you have a ref counted object with a
    ref count that should've gone to zero but didn't. This tracker can
    tell you every ``TfRefPtr`` that's holding the ``TfRefBase`` and a
    stack trace where it was created or last assigned to.

    Clients can get a report of all watched instances and how many
    ``TfRefPtr`` objects are holding them using
    ``ReportAllWatchedCounts()`` (in python use ``Tf.RefPtrTracker()``
    .GetAllWatchedCountsReport()). You can see all of the stack traces
    using ``ReportAllTraces()`` (in python use ``Tf.RefPtrTracker()``
    .GetAllTracesReport()).

    Clients will typically enable tracking using code like this:

    .. code-block:: text

      #include "pxr/base/tf/refPtrTracker.h"
      
      class MyRefBaseType;
      typedef TfRefPtr<MyRefBaseType> MyRefBaseTypeRefPtr;
      
      TF_DECLARE_REFPTR_TRACK(MyRefBaseType);
      
      class MyRefBaseType {
      \.\.\.
      public:
          static bool _ShouldWatch(const MyRefBaseType\*);
      \.\.\.
      };
      
      TF_DEFINE_REFPTR_TRACK(MyRefBaseType, MyRefBaseType::_ShouldWatch);

    Note that the ``TF_DECLARE_REFPTR_TRACK()`` macro must be invoked
    before any use of the ``MyRefBaseTypeRefPtr`` type.

    The ``MyRefBaseType::_ShouldWatch()`` function returns ``true`` if the
    given instance of ``MyRefBaseType`` should be tracked. You can also
    use ``TfRefPtrTracker::WatchAll()`` to watch every instance (but that
    might use a lot of memory and time).

    If you have a base type, ``B`` , and a derived type, ``D`` , and you
    hold instances of ``D`` in a ``TfRefPtr < ``B>```` (i.e. a pointer to
    the base) then you must track both type ``B`` and type ``D`` . But you
    can use ``TfRefPtrTracker::WatchNone()`` when tracking ``B`` if you're
    not interested in instances of ``B`` .
    """
    @staticmethod
    def GetAllTracesReport(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAllWatchedCountsReport(*args, **kwargs) -> None: ...
    @staticmethod
    def GetTracesReportForWatched(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    pass
class ScopeDescription(Boost.Python.instance):
    """
    This class is used to provide high-level descriptions about scopes of
    execution that could possibly block, or to provide relevant
    information about high-level action that would be useful in a crash
    report.

    This class is reasonably fast to use, especially if the message
    strings are not dynamically created, however it should not be used in
    very highly performance sensitive contexts. The cost to push & pop is
    essentially a TLS lookup plus a couple of atomic operations.
    """
    @staticmethod
    def SetDescription(description) -> None: 
        """
        SetDescription(description) -> None


        Replace the description stack entry for this scope description.


        Caller guarantees that the string ``description`` lives at least as
        long as this TfScopeDescription object.


        Parameters
        ----------
        description : str



        ----------------------------------------------------------------------


        Replace the description stack entry for this scope description.


        This object adopts ownership of the rvalue ``description`` .


        Parameters
        ----------
        description : str



        ----------------------------------------------------------------------


        Replace the description stack entry for this scope description.


        Caller guarantees that the string ``description`` lives at least as
        long as this TfScopeDescription object.


        Parameters
        ----------
        description : char
        """
    __instance_size__ = 56
    pass
class ScriptModuleLoader(Boost.Python.instance):
    """
    Provides low-level facilities for shared modules with script
    bindings to register themselves with their dependences, and provides a
    mechanism whereby those script modules will be loaded when necessary.
    Currently, this is when one of our script modules is loaded, when
    TfPyInitialize is called, and when Plug opens shared modules.

    Generally, user code will not make use of this.
    """
    @staticmethod
    def GetModuleNames() -> list[str]: 
        """
        GetModuleNames() -> list[str]


        Return a list of all currently known modules in a valid dependency
        order.
        """
    @staticmethod
    def GetModulesDict() -> python.dict: 
        """
        GetModulesDict() -> python.dict


        Return a python dict containing all currently known modules under
        their canonical names.
        """
    @staticmethod
    def WriteDotFile(file) -> None: 
        """
        WriteDotFile(file) -> None


        Write a graphviz dot-file for the dependency graph of all.


        currently known modules/modules to *file*.


        Parameters
        ----------
        file : str
        """
    @staticmethod
    def _LoadModulesForLibrary(*args, **kwargs) -> None: ...
    @staticmethod
    def _RegisterLibrary(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    pass
class Singleton(Boost.Python.instance):
    pass
class StatusObject(_DiagnosticBase, Boost.Python.instance):
    pass
class Stopwatch(Boost.Python.instance):
    @staticmethod
    def AddFrom(t) -> None: 
        """
        AddFrom(t) -> None


        Adds the accumulated time and sample count from ``t`` into the
        ``TfStopwatch`` .


        If you have several timers taking measurements, and you wish to
        combine them together, you can add one timer's results into another;
        for example, ``t2.AddFrom(t1)`` will add ``t1`` 's time and sample
        count into ``t2`` .


        Parameters
        ----------
        t : Stopwatch
        """
    @staticmethod
    def Reset() -> None: 
        """
        Reset() -> None


        Resets the accumulated time and the sample count to zero.
        """
    @staticmethod
    def Start() -> None: 
        """
        Start() -> None


        Record the current time for use by the next ``Stop()`` call.


        The ``Start()`` function records the current time. A subsequent call
        to ``Start()`` before a call to ``Stop()`` simply records a later
        current time, but does not change the accumulated time of the
        ``TfStopwatch`` .
        """
    @staticmethod
    def Stop() -> None: 
        """
        Stop() -> None


        Increases the accumulated time stored in the ``TfStopwatch`` .


        The ``Stop()`` function increases the accumulated time by the duration
        between the current time and the last time recorded by a ``Start()``
        call. A subsequent call to ``Stop()`` before another call to
        ``Start()`` will therefore double-count time and throw off the
        results.

        A ``TfStopwatch`` also counts the number of samples it has taken.
        The"sample count"is simply the number of times that ``Stop()`` has
        been called.
        """
    @property
    def microseconds(self) -> None:
        """
        type : int


        Return the accumulated time in microseconds.


        Note that 45 minutes will overflow a 32-bit counter, so take care to
        save the result in an ``int64_t`` , and not a regular ``int`` or
        ``long`` .

        :type: None
        """
    @property
    def milliseconds(self) -> None:
        """
        type : int


        Return the accumulated time in milliseconds.

        :type: None
        """
    @property
    def nanoseconds(self) -> None:
        """
        type : int


        Return the accumulated time in nanoseconds.


        Note that this number can easily overflow a 32-bit counter, so take
        care to save the result in an ``int64_t`` , and not a regular ``int``
        or ``long`` .

        :type: None
        """
    @property
    def sampleCount(self) -> None:
        """
        type : int


        Return the current sample count.


        The sample count, which is simply the number of calls to ``Stop()``
        since creation or a call to ``Reset()`` , is useful for computing
        average running times of a repeated task.

        :type: None
        """
    @property
    def seconds(self) -> None:
        """
        type : float


        Return the accumulated time in seconds as a ``double`` .

        :type: None
        """
    __instance_size__ = 40
    pass
class TemplateString(Boost.Python.instance):
    @staticmethod
    def GetEmptyMapping() -> Mapping: 
        """
        GetEmptyMapping() -> Mapping


        Returns an empty mapping for the current template.


        This method first calls IsValid to ensure that the template is valid.
        """
    @staticmethod
    def GetParseErrors() -> list[str]: 
        """
        GetParseErrors() -> list[str]


        Returns any error messages generated during template parsing.
        """
    @staticmethod
    def SafeSubstitute(arg1) -> str: 
        """
        SafeSubstitute(arg1) -> str


        Like Substitute() , except that if placeholders are missing from the
        mapping, instead of raising a coding error, the original placeholder
        will appear in the resulting string intact.


        Parameters
        ----------
        arg1 : Mapping
        """
    @staticmethod
    def Substitute(arg1) -> str: 
        """
        Substitute(arg1) -> str


        Performs the template substitution, returning a new string.


        The mapping contains keys which match the placeholders in the
        template. If a placeholder is found for which no mapping is present, a
        coding error is raised.


        Parameters
        ----------
        arg1 : Mapping
        """
    @property
    def template(self) -> None:
        """
        type : str


        Returns the template source string supplied to the constructor.

        :type: None
        """
    @property
    def valid(self) -> None:
        """
        type : bool


        Returns true if the current template is well formed.


        Empty templates are valid.

        :type: None
        """
    __instance_size__ = 32
    pass
class Tf_PyEnumWrapper(Enum, Boost.Python.instance):
    @property
    def displayName(self) -> None:
        """
        :type: None
        """
    @property
    def fullName(self) -> None:
        """
        :type: None
        """
    @property
    def name(self) -> None:
        """
        :type: None
        """
    @property
    def value(self) -> None:
        """
        :type: None
        """
    pass
class Tf_TestAnnotatedBoolResult(Boost.Python.instance):
    @property
    def annotation(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 56
    pass
class Tf_TestPyContainerConversions(Boost.Python.instance):
    @staticmethod
    def GetPairTimesTwo(*args, **kwargs) -> None: ...
    @staticmethod
    def GetTokens(*args, **kwargs) -> None: ...
    @staticmethod
    def GetVectorTimesTwo(*args, **kwargs) -> None: ...
    __instance_size__ = 24
    pass
class Tf_TestPyOptional(Boost.Python.instance):
    @staticmethod
    def TakesOptional(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalChar(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalDouble(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalFloat(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalInt(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalLong(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalShort(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalString(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalStringVector(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalUChar(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalUInt(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalULong(*args, **kwargs) -> None: ...
    @staticmethod
    def TestOptionalUShort(*args, **kwargs) -> None: ...
    __instance_size__ = 24
    pass
class Type(Boost.Python.instance):
    """
    TfType represents a dynamic runtime type.

    TfTypes are created and discovered at runtime, rather than compile
    time.

    Features:

       - unique typename

       - safe across DSO boundaries

       - can represent C++ types, pure Python types, or Python subclasses
         of wrapped C++ types

       - lightweight value semantics  you can copy and default construct
         TfType, unlike ``std::type_info`` .

       - totally ordered  can use as a ``std::map`` key
    """
    @staticmethod
    def AddAlias(name) -> None: 
        """
        **classmethod** AddAlias(base, name) -> None


        Add an alias name for this type under the given base type.


        Aliases are similar to typedefs in C++: they provide an alternate name
        for a type. The alias is defined with respect to the given ``base``
        type. Aliases must be unique with respect to both other aliases
        beneath that base type and names of derived types of that base.


        Parameters
        ----------
        base : Type

        name : str



        ----------------------------------------------------------------------


        Add an alias for DERIVED beneath BASE.


        This is a convenience method, that declares both DERIVED and BASE as
        TfTypes before adding the alias.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def Define() -> Type: 
        """
        **classmethod** Define() -> Type


        Define a TfType with the given C++ type T and C++ base types B.


        Each of the base types will be declared (but not defined) as TfTypes
        if they have not already been.

        The typeName of the created TfType will be the canonical demangled
        RTTI type name, as defined by GetCanonicalTypeName() .

        It is an error to attempt to define a type that has already been
        defined.




        ----------------------------------------------------------------------


        Define a TfType with the given C++ type T and no bases.


        See the other Define() template for more details.

        C++ does not allow default template arguments for function templates,
        so we provide this separate definition for the case of no bases.
        """
    @staticmethod
    @typing.overload
    def Find(obj) -> Type: 
        """
        **classmethod** Find() -> Type


        Retrieve the ``TfType`` corresponding to type ``T`` .


        The type ``T`` must have been declared or defined in the type system
        or the ``TfType`` corresponding to an unknown type is returned.




        ----------------------------------------------------------------------


        Retrieve the ``TfType`` corresponding to ``obj`` .


        The ``TfType`` corresponding to the actual object represented by
        ``obj`` is returned; this may not be the object returned by
        ``TfType::Find<T>()`` if ``T`` is a polymorphic type.

        This works for Python subclasses of the C++ type ``T`` as well, as
        long as ``T`` has been wrapped using TfPyPolymorphic.

        Of course, the object's type must have been declared or defined in the
        type system or the ``TfType`` corresponding to an unknown type is
        returned.


        Parameters
        ----------
        obj : T



        ----------------------------------------------------------------------


        Retrieve the ``TfType`` corresponding to an obj with the given
        ``type_info`` .


        Parameters
        ----------
        t : type_info
        """
    @staticmethod
    @typing.overload
    def Find(t) -> Type: ...
    @staticmethod
    def FindByName(*args, **kwargs) -> None: 
        """
        **classmethod** FindByName(name) -> Type


        Retrieve the ``TfType`` corresponding to the given ``name`` .


        Every type defined in the TfType system has a unique, implementation
        independent name. In addition, aliases can be added to identify a type
        underneath a specific base type; see TfType::AddAlias() . The given
        name will first be tried as an alias under the root type, and
        subsequently as a typename.

        This method is equivalent to:

        .. code-block:: text

          TfType::GetRoot().FindDerivedByName(name)

        For any object ``obj`` ,

        .. code-block:: text

          Find(obj) == FindByName( Find(obj).GetTypeName() )



        Parameters
        ----------
        name : str
        """
    @staticmethod
    def FindDerivedByName(name) -> Type: 
        """
        **classmethod** FindDerivedByName(name) -> Type


        Retrieve the ``TfType`` that derives from this type and has the given
        alias or typename.



        AddAlias


        Parameters
        ----------
        name : str



        ----------------------------------------------------------------------


        Retrieve the ``TfType`` that derives from BASE and has the given alias
        or typename.


        This is a convenience method, and is equivalent to:

        .. code-block:: text

          TfType::Find<BASE>().FindDerivedByName(name)



        Parameters
        ----------
        name : str
        """
    @staticmethod
    def GetAliases(derivedType) -> list[str]: 
        """
        GetAliases(derivedType) -> list[str]


        Returns a vector of the aliases registered for the derivedType under
        this, the base type.




        Parameters
        ----------
        derivedType : Type
        """
    @staticmethod
    def GetAllAncestorTypes(result) -> None: 
        """
        GetAllAncestorTypes(result) -> None


        Build a vector of all ancestor types inherited by this type.


        The starting type is itself included, as the first element of the
        results vector.

        Types are given in"C3"resolution order, as used for new-style classes
        starting in Python 2.3. This algorithm is more complicated than a
        simple depth-first traversal of base classes, in order to prevent some
        subtle errors with multiple-inheritance. See the references below for
        more background.

        This can be expensive; consider caching the results. TfType does not
        cache this itself since it is not needed internally.

        Guido van Rossum."Unifying types and classes in Python 2.2: Method
        resolution order."
        http://www.python.org/download/releases/2.2.2/descrintro/#mro

        Barrett, Cassels, Haahr, Moon, Playford, Withington."A Monotonic
        Superclass Linearization for Dylan."OOPSLA 96.
        http://www.webcom.com/haahr/dylan/linearization-oopsla96.html


        Parameters
        ----------
        result : list[Type]
        """
    @staticmethod
    def GetAllDerivedTypes(result) -> None: 
        """
        GetAllDerivedTypes(result) -> None


        Return the set of all types derived (directly or indirectly) from this
        type.


        Parameters
        ----------
        result : set[Type]
        """
    @staticmethod
    def GetRoot(*args, **kwargs) -> None: 
        """
        **classmethod** GetRoot() -> Type


        Return the root type of the type hierarchy.


        All known types derive (directly or indirectly) from the root. If a
        type is specified with no bases, it is implicitly considered to derive
        from the root type.
        """
    @staticmethod
    @typing.overload
    def IsA(queryType) -> bool: 
        """
        IsA(queryType) -> bool


        Return true if this type is the same as or derived from ``queryType``
        .


        If ``queryType`` is unknown, this always returns ``false`` .


        Parameters
        ----------
        queryType : Type



        ----------------------------------------------------------------------


        Return true if this type is the same as or derived from T.


        This is equivalent to:

        .. code-block:: text

          IsA(Find<T>())
        """
    @staticmethod
    @typing.overload
    def IsA() -> bool: ...
    @staticmethod
    def _DumpTypeHierarchy(*args, **kwargs) -> None: ...
    @property
    def baseTypes(self) -> None:
        """
        type : list[Type]


        Return a vector of types from which this type was derived.

        :type: None
        """
    @property
    def derivedTypes(self) -> None:
        """
        :type: None
        """
    @property
    def isEnumType(self) -> None:
        """
        type : bool


        Return true if this is an enum type.

        :type: None
        """
    @property
    def isPlainOldDataType(self) -> None:
        """
        type : bool


        Return true if this is a plain old data type, as defined by C++.

        :type: None
        """
    @property
    def isUnknown(self) -> None:
        """
        type : bool


        Return true if this is the unknown type, representing a type unknown
        to the TfType system.


        The unknown type does not derive from the root type, or any other
        type.

        :type: None
        """
    @property
    def pythonClass(self) -> None:
        """
        type : TfPyObjWrapper


        Return the Python class object for this type.


        If this type is unknown or has not yet had a Python class defined,
        this will return ``None`` , as an empty ``TfPyObjWrapper``

        :type: None
        """
    @property
    def sizeof(self) -> None:
        """
        type : int


        Return the size required to hold an instance of this type on the stack
        (does not include any heap allocated memory the instance uses).


        This is what the C++ sizeof operator returns for the type, so this
        value is not very useful for Python types (it will always be
        sizeof(boost::python::object)).

        :type: None
        """
    @property
    def typeName(self) -> None:
        """
        type : str


        Return the machine-independent name for this type.


        This name is specified when the TfType is declared.

        :type: None
        """
    Unknown: pxr.Tf.Type # value = Tf.Type.Unknown
    __instance_size__ = 24
    pass
class Warning(_DiagnosticBase, Boost.Python.instance):
    pass
class _ClassWithClassMethod(Boost.Python.instance):
    @staticmethod
    def Test(*args, **kwargs) -> None: ...
    __instance_size__ = 24
    pass
class _ClassWithVarArgInit(Boost.Python.instance):
    @property
    def allowExtraArgs(self) -> None:
        """
        :type: None
        """
    @property
    def args(self) -> None:
        """
        :type: None
        """
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    @property
    def kwargs(self) -> None:
        """
        :type: None
        """
    pass
class _DiagnosticBase(Boost.Python.instance):
    @property
    def commentary(self) -> None:
        """
        The commentary string describing this error.

        :type: None
        """
    @property
    def diagnosticCode(self) -> None:
        """
        The diagnostic code posted.

        :type: None
        """
    @property
    def diagnosticCodeString(self) -> None:
        """
        The error code posted for this error, as a string.

        :type: None
        """
    @property
    def sourceFileName(self) -> None:
        """
        The source file name that the error was posted from.

        :type: None
        """
    @property
    def sourceFunction(self) -> None:
        """
        The source function that the error was posted from.

        :type: None
        """
    @property
    def sourceLineNumber(self) -> None:
        """
        The source line number that the error was posted from.

        :type: None
        """
    pass
class _Enum(Boost.Python.instance):
    class TestEnum2(Tf_PyEnumWrapper, Enum, Boost.Python.instance):
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = '_Enum'
        allValues: tuple # value = (Tf._Enum.One, Tf._Enum.Two, Tf._Enum.Three)
        pass
    class TestKeywords(Tf_PyEnumWrapper, Enum, Boost.Python.instance):
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        False_: pxr.Tf.TestKeywords # value = Tf._Enum.TestKeywords.False_
        None_: pxr.Tf.TestKeywords # value = Tf._Enum.TestKeywords.None_
        True_: pxr.Tf.TestKeywords # value = Tf._Enum.TestKeywords.True_
        _baseName = '_Enum.TestKeywords'
        allValues: tuple # value = (Tf._Enum.TestKeywords.None_, Tf._Enum.TestKeywords.False_, Tf._Enum.TestKeywords.True_, Tf._Enum.TestKeywords.print_, Tf._Enum.TestKeywords.import_, Tf._Enum.TestKeywords.global_)
        global_: pxr.Tf.TestKeywords # value = Tf._Enum.TestKeywords.global_
        import_: pxr.Tf.TestKeywords # value = Tf._Enum.TestKeywords.import_
        print_: pxr.Tf.TestKeywords # value = Tf._Enum.TestKeywords.print_
        pass
    class TestScopedEnum(Tf_PyEnumWrapper, Enum, Boost.Python.instance):
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        Alef: pxr.Tf.TestScopedEnum # value = Tf._Enum.TestScopedEnum.Alef
        Bet: pxr.Tf.TestScopedEnum # value = Tf._Enum.TestScopedEnum.Bet
        Gimel: pxr.Tf.TestScopedEnum # value = Tf._Enum.TestScopedEnum.Gimel
        _baseName = '_Enum.TestScopedEnum'
        allValues: tuple # value = (Tf._Enum.TestScopedEnum.Alef, Tf._Enum.TestScopedEnum.Bet, Tf._Enum.TestScopedEnum.Gimel)
        pass
    One: pxr.Tf.TestEnum2 # value = Tf._Enum.One
    Three: pxr.Tf.TestEnum2 # value = Tf._Enum.Three
    Two: pxr.Tf.TestEnum2 # value = Tf._Enum.Two
    pass
class _TestDerived(_TestBase, Boost.Python.instance):
    @staticmethod
    def Virtual(*args, **kwargs) -> None: ...
    @staticmethod
    def Virtual2(*args, **kwargs) -> None: ...
    @staticmethod
    def Virtual3(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    pass
class _TestBase(Boost.Python.instance):
    @staticmethod
    def TestCallVirtual(*args, **kwargs) -> None: ...
    @staticmethod
    def Virtual(*args, **kwargs) -> None: ...
    @staticmethod
    def Virtual2(*args, **kwargs) -> None: ...
    @staticmethod
    def Virtual3(*args, **kwargs) -> None: ...
    @staticmethod
    def Virtual4(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    pass
class _TestEnum(Tf_PyEnumWrapper, Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Tf._Alpha, Tf._Bravo, Tf._Charlie, Tf._Delta)
    pass
class _TestScopedEnum(Tf_PyEnumWrapper, Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    Beryllium: pxr.Tf._TestScopedEnum # value = Tf._TestScopedEnum.Beryllium
    Boron: pxr.Tf._TestScopedEnum # value = Tf._TestScopedEnum.Boron
    Hydrogen: pxr.Tf._TestScopedEnum # value = Tf._TestScopedEnum.Hydrogen
    Lithium: pxr.Tf._TestScopedEnum # value = Tf._TestScopedEnum.Lithium
    _baseName = '_TestScopedEnum'
    allValues: tuple # value = (Tf._TestScopedEnum.Hydrogen, Tf._TestScopedEnum.Lithium, Tf._TestScopedEnum.Beryllium, Tf._TestScopedEnum.Boron)
    pass
class _TestStaticMethodError(Boost.Python.instance):
    @staticmethod
    def Error(*args, **kwargs) -> None: ...
    pass
class _TestStaticTokens(Boost.Python.instance):
    Fuji = 'Fuji'
    McIntosh = 'McIntosh'
    Pippin = 'Pippin'
    orange = 'orange'
    pear = "d'Anjou"
    pass
class _testStaticTokens(Boost.Python.instance):
    Fuji = 'Fuji'
    McIntosh = 'McIntosh'
    Pippin = 'Pippin'
    orange = 'orange'
    pear = "d'Anjou"
    pass
def DictionaryStrcmp(*args, **kwargs) -> None:
    pass
def DumpTokenStats(*args, **kwargs) -> None:
    pass
def FindLongestAccessiblePrefix(*args, **kwargs) -> None:
    pass
def GetAppLaunchTime() -> int :
    """
    Return the time (in seconds since the epoch) at which the application was started.
    """
def GetCurrentScopeDescriptionStack(*args, **kwargs) -> None:
    pass
def GetEnvSetting(*args, **kwargs) -> None:
    pass
def GetStackTrace(*args, **kwargs) -> None:
    """
    Return both the C++ and the python stack as a string.
    """
def InstallTerminateAndCrashHandlers() -> None:
    """
    InstallTerminateAndCrashHandlers() -> None


    (Re)install Tf's crash handler.


    This should not generally need to be called since Tf does this itself
    when loaded. However, when run in 3rd party environments that install
    their own signal handlers, possibly overriding Tf's, this provides a
    way to reinstall them, in hopes that they'll stick.

    This calls std::set_terminate() and installs signal handlers for
    SIGSEGV, SIGBUS, SIGFPE, and SIGABRT.
    """
def InvokeWithErrorHandling(*args, **kwargs) -> None:
    pass
def IsValidIdentifier(identifier) -> bool:
    """
    IsValidIdentifier(identifier) -> bool


    Test whether *identifier* is valid.


    An identifier is valid if it follows the C/Python identifier
    convention; that is, it must be at least one character long, must
    start with a letter or underscore, and must contain only letters,
    underscores, and numerals.


    Parameters
    ----------
    identifier : str
    """
def LogStackTrace(*args, **kwargs) -> None:
    pass
def MakeValidIdentifier(*args, **kwargs) -> typing.Any:
    """
    MakeValidIdentifier(in) -> str


    Produce a valid identifier (see TfIsValidIdentifier) from ``in`` by
    replacing invalid characters with'_'.


    If ``in`` is empty, return"_".


    Parameters
    ----------
    in : str
    """
def PrintStackTrace(*args, **kwargs) -> None:
    """
    Prints both the C++ and the python stack to the file provided.
    """
def RealPath(*args, **kwargs) -> None:
    pass
def ReportActiveErrorMarks() -> None:
    """
    ReportActiveErrorMarks() -> None


    Report current TfErrorMark instances and the stack traces that created
    them to stdout for debugging purposes.


    To call this function, set _enableTfErrorMarkStackTraces in
    errorMark.cpp and enable the TF_ERROR_MARK_TRACKING TfDebug code.
    """
def RepostErrors(*args, **kwargs) -> None:
    pass
def SetPythonExceptionDebugTracingEnabled(*args, **kwargs) -> None:
    pass
def StringSplit(src, separator) -> list[str]:
    """
    StringSplit(src, separator) -> list[str]


    Breaks the given string apart, returning a vector of strings.


    The string ``source`` is broken apart into individual words, where a
    word is delimited by the string ``separator`` . This function behaves
    like pythons string split method.


    Parameters
    ----------
    src : str

    separator : str
    """
@typing.overload
def StringToDouble(txt) -> float:
    """
    StringToDouble(txt) -> float


    Converts text string to double.


    This method converts strings to floating point numbers. It is similar
    to libc's atof(), but performs the conversion much more quickly.

    It expects somewhat valid input: it will continue parsing the input
    until it hits an unrecognized character, as described by the regexp
    below, and at that point will return the results up to that point.

    (-?[0-9]+(.[0-9]\*)?|-?.[0-9]+)([eE][-+]?[0-9]+)?

    It will not check to see if there is any input at all, or whitespace
    after the digits. Ie: TfStringToDouble("") == 0.0
    TfStringToDouble("blah") == 0.0 TfStringToDouble("-") == -0.0
    TfStringToDouble("1.2foo") == 1.2

    ``TfStringToDouble`` is a wrapper around the extern-c TfStringToDouble


    Parameters
    ----------
    txt : str



    ----------------------------------------------------------------------


    This is an overloaded member function, provided for convenience. It
    differs from the above function only in what argument(s) it accepts.


    Parameters
    ----------
    text : str



    ----------------------------------------------------------------------


    This is an overloaded member function, provided for convenience. It
    differs from the above function only in what argument(s) it accepts.


    Parameters
    ----------
    text : str

    len : int
    """
@typing.overload
def StringToDouble(text) -> float:
    pass
@typing.overload
def StringToDouble(text, len) -> float:
    pass
def StringToLong(txt, outOfRange) -> long:
    """
    StringToLong(txt, outOfRange) -> long


    Convert a sequence of digits in ``txt`` to a long int value.


    Caller is responsible for ensuring that ``txt`` has content matching:

    .. code-block:: text

      -?[0-9]+

    If the digit sequence's value is out of range, set ``\*outOfRange``
    to true (if ``outOfRange`` is not None) and return either
    std::numeric_limits<long>::min() or max(), whichever is closest to the
    true value.


    Parameters
    ----------
    txt : str

    outOfRange : bool



    ----------------------------------------------------------------------


    This is an overloaded member function, provided for convenience. It
    differs from the above function only in what argument(s) it accepts.


    Parameters
    ----------
    txt : str

    outOfRange : bool
    """
def StringToULong(txt, outOfRange) -> int:
    """
    StringToULong(txt, outOfRange) -> int


    Convert a sequence of digits in ``txt`` to an unsigned long value.


    Caller is responsible for ensuring that ``txt`` has content matching:

    .. code-block:: text

      [0-9]+

    If the digit sequence's value is out of range, set ``\*outOfRange``
    to true (if ``outOfRange`` is not None) and return
    std::numeric_limits<unsignedlong>::max().


    Parameters
    ----------
    txt : str

    outOfRange : bool



    ----------------------------------------------------------------------


    This is an overloaded member function, provided for convenience. It
    differs from the above function only in what argument(s) it accepts.


    Parameters
    ----------
    txt : str

    outOfRange : bool
    """
def TouchFile(*args, **kwargs) -> None:
    pass
def _CallThrowTest(*args, **kwargs) -> None:
    pass
def _ConvertByteListToByteArray(*args, **kwargs) -> None:
    pass
def _DerivedFactory(*args, **kwargs) -> None:
    pass
def _DerivedNullFactory(*args, **kwargs) -> None:
    pass
def _Fatal(*args, **kwargs) -> None:
    pass
def _GetLongMax(*args, **kwargs) -> None:
    pass
def _GetLongMin(*args, **kwargs) -> None:
    pass
def _GetULongMax(*args, **kwargs) -> None:
    pass
def _RaiseCodingError(*args, **kwargs) -> None:
    pass
def _RaiseRuntimeError(*args, **kwargs) -> None:
    pass
def _ReturnsBase(*args, **kwargs) -> None:
    pass
def _ReturnsBaseRefPtr(*args, **kwargs) -> None:
    pass
def _ReturnsConstBase(*args, **kwargs) -> None:
    pass
def _RoundTripWrapperCallTest(*args, **kwargs) -> None:
    pass
def _RoundTripWrapperIndexTest(*args, **kwargs) -> None:
    pass
def _RoundTripWrapperTest(*args, **kwargs) -> None:
    pass
def _Status(*args, **kwargs) -> None:
    pass
def _TakesBase(*args, **kwargs) -> None:
    pass
def _TakesConstBase(*args, **kwargs) -> None:
    pass
def _TakesDerived(*args, **kwargs) -> None:
    pass
def _TakesReference(*args, **kwargs) -> None:
    pass
def _TakesVecVecString(*args, **kwargs) -> None:
    pass
def _TestAnnotatedBoolResult(*args, **kwargs) -> None:
    pass
def _ThrowCppException(*args, **kwargs) -> None:
    pass
def _ThrowTest(*args, **kwargs) -> None:
    pass
def _Warn(*args, **kwargs) -> None:
    pass
def __SetErrorExceptionClass(*args, **kwargs) -> None:
    pass
def _callUnboundInstance(*args, **kwargs) -> None:
    pass
def _callback(*args, **kwargs) -> None:
    pass
def _doErrors(*args, **kwargs) -> None:
    pass
def _invokeTestCallback(*args, **kwargs) -> None:
    pass
def _mightRaise(*args, **kwargs) -> None:
    pass
def _registerInvalidEnum(*args, **kwargs) -> None:
    pass
def _returnsTfEnum(*args, **kwargs) -> None:
    pass
def _sendTfNoticeWithSender(*args, **kwargs) -> None:
    pass
def _setTestCallback(*args, **kwargs) -> None:
    pass
def _stringCallback(*args, **kwargs) -> None:
    pass
def _stringStringCallback(*args, **kwargs) -> None:
    pass
def _takesTestEnum(*args, **kwargs) -> None:
    pass
def _takesTestEnum2(*args, **kwargs) -> None:
    pass
def _takesTfEnum(*args, **kwargs) -> None:
    pass
TF_APPLICATION_EXIT_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_APPLICATION_EXIT_TYPE
TF_DIAGNOSTIC_CODING_ERROR_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_DIAGNOSTIC_CODING_ERROR_TYPE
TF_DIAGNOSTIC_FATAL_CODING_ERROR_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_DIAGNOSTIC_FATAL_CODING_ERROR_TYPE
TF_DIAGNOSTIC_FATAL_ERROR_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_DIAGNOSTIC_FATAL_ERROR_TYPE
TF_DIAGNOSTIC_NONFATAL_ERROR_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_DIAGNOSTIC_NONFATAL_ERROR_TYPE
TF_DIAGNOSTIC_RUNTIME_ERROR_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_DIAGNOSTIC_RUNTIME_ERROR_TYPE
TF_DIAGNOSTIC_STATUS_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_DIAGNOSTIC_STATUS_TYPE
TF_DIAGNOSTIC_WARNING_TYPE: pxr.Tf.DiagnosticType # value = Tf.TF_DIAGNOSTIC_WARNING_TYPE
_Alpha: pxr.Tf._TestEnum # value = Tf._Alpha
_Bravo: pxr.Tf._TestEnum # value = Tf._Bravo
_Charlie: pxr.Tf._TestEnum # value = Tf._Charlie
_Delta: pxr.Tf._TestEnum # value = Tf._Delta
__MFB_FULL_PACKAGE_NAME = 'tf'
