from __future__ import annotations
import pxr.Sdf._sdf
import typing
import Boost.Python
import pxr.Sdf
import pxr.Tf

__all__ = [
    "AngularUnit",
    "AngularUnitDegrees",
    "AngularUnitRadians",
    "AssetPath",
    "AssetPathArray",
    "AttributeSpec",
    "AuthoringError",
    "AuthoringErrorUnrecognizedFields",
    "AuthoringErrorUnrecognizedSpecType",
    "BatchNamespaceEdit",
    "Cat",
    "ChangeBlock",
    "ChildrenView_Sdf_AttributeChildPolicy_SdfAttributeViewPredicate",
    "ChildrenView_Sdf_AttributeChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfAttributeSpec___",
    "ChildrenView_Sdf_PrimChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPrimSpec___",
    "ChildrenView_Sdf_PropertyChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPropertySpec___",
    "ChildrenView_Sdf_RelationshipChildPolicy_SdfRelationshipViewPredicate",
    "ChildrenView_Sdf_VariantChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSpec___",
    "ChildrenView_Sdf_VariantSetChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSetSpec___",
    "CleanupEnabler",
    "ComputeAssetPathRelativeToLayer",
    "ConvertToValidMetadataDictionary",
    "ConvertUnit",
    "CopySpec",
    "CreatePrimInLayer",
    "CreateVariantInLayer",
    "DefaultUnit",
    "DimensionlessUnit",
    "DimensionlessUnitDefault",
    "DimensionlessUnitPercent",
    "Equal",
    "FastUpdateList",
    "FileFormat",
    "GetNameForUnit",
    "GetTypeForValueTypeName",
    "GetUnitFromName",
    "GetValueTypeNameForValue",
    "Int64ListOp",
    "IntListOp",
    "JustCreatePrimAttributeInLayer",
    "JustCreatePrimInLayer",
    "Layer",
    "LayerOffset",
    "LayerTree",
    "LengthUnit",
    "LengthUnitCentimeter",
    "LengthUnitDecimeter",
    "LengthUnitFoot",
    "LengthUnitInch",
    "LengthUnitKilometer",
    "LengthUnitMeter",
    "LengthUnitMile",
    "LengthUnitMillimeter",
    "LengthUnitYard",
    "ListEditorProxy_SdfNameKeyPolicy",
    "ListEditorProxy_SdfPathKeyPolicy",
    "ListEditorProxy_SdfPayloadTypePolicy",
    "ListEditorProxy_SdfReferenceTypePolicy",
    "ListOpType",
    "ListOpTypeAdded",
    "ListOpTypeAppended",
    "ListOpTypeDeleted",
    "ListOpTypeExplicit",
    "ListOpTypeOrdered",
    "ListOpTypePrepended",
    "ListProxy_SdfNameKeyPolicy",
    "ListProxy_SdfNameTokenKeyPolicy",
    "ListProxy_SdfPathKeyPolicy",
    "ListProxy_SdfPayloadTypePolicy",
    "ListProxy_SdfReferenceTypePolicy",
    "ListProxy_SdfSubLayerTypePolicy",
    "MapEditProxy_VtDictionary",
    "MapEditProxy_map_SdfPath_SdfPath_less_SdfPath__allocator_pair_SdfPath_const__SdfPath_____",
    "MapEditProxy_map_string_string_less_string__allocator_pair_stringconst__string_____",
    "NamespaceEdit",
    "NamespaceEditDetail",
    "NotEqual",
    "Notice",
    "Path",
    "PathArray",
    "PathListOp",
    "Payload",
    "PayloadListOp",
    "Permission",
    "PermissionPrivate",
    "PermissionPublic",
    "PrimSpec",
    "PropertySpec",
    "PseudoRootSpec",
    "Reference",
    "ReferenceListOp",
    "RelationshipSpec",
    "Spec",
    "SpecType",
    "SpecTypeAttribute",
    "SpecTypeConnection",
    "SpecTypeExpression",
    "SpecTypeMapper",
    "SpecTypeMapperArg",
    "SpecTypePrim",
    "SpecTypePseudoRoot",
    "SpecTypeRelationship",
    "SpecTypeRelationshipTarget",
    "SpecTypeUnknown",
    "SpecTypeVariant",
    "SpecTypeVariantSet",
    "Specifier",
    "SpecifierClass",
    "SpecifierDef",
    "SpecifierOver",
    "StringListOp",
    "TimeCode",
    "TimeCodeArray",
    "TokenListOp",
    "UInt64ListOp",
    "UIntListOp",
    "UnitCategory",
    "UnregisteredValue",
    "UnregisteredValueListOp",
    "ValueBlock",
    "ValueHasValidType",
    "ValueRoleNames",
    "ValueTypeName",
    "ValueTypeNames",
    "Variability",
    "VariabilityUniform",
    "VariabilityVarying",
    "VariantSetSpec",
    "VariantSpec"
]


class AngularUnit(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.AngularUnitDegrees, Sdf.AngularUnitRadians)
    pass
class AssetPath(Boost.Python.instance):
    """
    Contains an asset path and an optional resolved path. Asset paths may
    contain non-control UTF-8 encoded characters. Specifically,
    U+0000\.\.U+001F (C0 controls), U+007F (delete), and
    U+0080\.\.U+009F (C1 controls) are disallowed. Attempts to construct
    asset paths with such characters will issue a TfError and produce the
    default-constructed empty asset path.
    """
    @property
    def path(self) -> None:
        """
        :type: None
        """
    @property
    def resolvedPath(self) -> None:
        """
        type : str


        Return the resolved asset path, if any.


        Note that SdfAssetPath carries a resolved path only if its creator
        passed one to the constructor. SdfAssetPath never performs resolution
        itself.


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

        type : str


        Overload for rvalues, move out the asset path.

        :type: None
        """
    __instance_size__ = 80
    pass
class AssetPathArray(Boost.Python.instance):
    """
    An array of type SdfAssetPath.
    """
    _isVtArray = True
    pass
class AttributeSpec(PropertySpec, Spec, Boost.Python.instance):
    """
    A subclass of SdfPropertySpec that holds typed data.

    Attributes are typed data containers that can optionally hold any and
    all of the following:

       - A single default value.

       - An array of knot values describing how the value varies over
         time.

       - A dictionary of posed values, indexed by name.
         The values contained in an attribute must all be of the same type. In
         the Python API the ``typeName`` property holds the attribute type. In
         the C++ API, you can get the attribute type using the GetTypeName()
         method. In addition, all values, including all knot values, must be
         the same shape. For information on shapes, see the VtShape class
         reference in the C++ documentation.
    """
    @staticmethod
    def ClearColorSpace() -> None: 
        """
        ClearColorSpace() -> None


        Clears the colorSpace metadata value set on this attribute.
        """
    @staticmethod
    def HasColorSpace() -> bool: 
        """
        HasColorSpace() -> bool


        Returns true if this attribute has a colorSpace value authored.
        """
    @property
    def allowedTokens(self) -> None:
        """
        The allowed value tokens for this property

        :type: None
        """
    @property
    def colorSpace(self) -> None:
        """
        The color-space in which the attribute value is authored.

        :type: None
        """
    @property
    def connectionPathList(self) -> None:
        """
        A PathListEditor for the attribute's connection paths.

        The list of the connection paths for this attribute may be modified with this PathListEditor.

        A PathListEditor may express a list either as an explicit value or as a set of list editing operations.  See GdListEditor for more information.

        :type: None
        """
    @property
    def displayUnit(self) -> None:
        """
        The display unit for this attribute.

        :type: None
        """
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    @property
    def roleName(self) -> None:
        """
        The roleName for this attribute's typeName.

        :type: None
        """
    @property
    def typeName(self) -> None:
        """
        The typename of this attribute.

        :type: None
        """
    @property
    def valueType(self) -> None:
        """
        The value type of this attribute.

        :type: None
        """
    ConnectionPathsKey = 'connectionPaths'
    DefaultValueKey = 'default'
    DisplayUnitKey = 'displayUnit'
    pass
class AuthoringError(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.AuthoringErrorUnrecognizedFields, Sdf.AuthoringErrorUnrecognizedSpecType)
    pass
class BatchNamespaceEdit(Boost.Python.instance):
    """
    A description of an arbitrarily complex namespace edit.

    A ``SdfBatchNamespaceEdit`` object describes zero or more namespace
    edits. Various types providing a namespace will allow the edits to be
    applied in a single operation and also allow testing if this will
    work.

    Clients are encouraged to group several edits into one object because
    that may allow more efficient processing of the edits. If, for
    example, you need to reparent several prims it may be faster to add
    all of the reparents to a single ``SdfBatchNamespaceEdit`` and apply
    them at once than to apply each separately.

    Objects that allow applying edits are free to apply the edits in any
    way and any order they see fit but they should guarantee that the
    resulting namespace will be as if each edit was applied one at a time
    in the order they were added.

    Note that the above rule permits skipping edits that have no effect or
    generate a non-final state. For example, if renaming A to B then to C
    we could just rename A to C. This means notices may be elided.
    However, implementations must not elide notices that contain
    information about any edit that clients must be able to know but
    otherwise cannot determine.
    """
    @staticmethod
    @typing.overload
    def Add(edit) -> None: 
        """
        Add(edit) -> None


        Add a namespace edit.


        Parameters
        ----------
        edit : NamespaceEdit



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


        Add a namespace edit.


        Parameters
        ----------
        currentPath : NamespaceEdit.Path

        newPath : NamespaceEdit.Path

        index : NamespaceEdit.Index
        """
    @staticmethod
    @typing.overload
    def Add(currentPath, newPath, index) -> None: ...
    @staticmethod
    def Process(processedEdits, hasObjectAtPath, canEdit, details, fixBackpointers) -> bool: 
        """
        Process(processedEdits, hasObjectAtPath, canEdit, details, fixBackpointers) -> bool


        Validate the edits and generate a possibly more efficient edit
        sequence.


        Edits are treated as if they were performed one at time in sequence,
        therefore each edit occurs in the namespace resulting from all
        previous edits.

        Editing the descendants of the object in each edit is implied. If an
        object is removed then the new path will be empty. If an object is
        removed after being otherwise edited, the other edits will be
        processed and included in ``processedEdits`` followed by the removal.
        This allows clients to fixup references to point to the object's final
        location prior to removal.

        This function needs help to determine if edits are allowed. The
        callbacks provide that help. ``hasObjectAtPath`` returns ``true`` iff
        there's an object at the given path. This path will be in the original
        namespace not any intermediate or final namespace. ``canEdit`` returns
        ``true`` iff the object at the current path can be namespace edited to
        the new path, ignoring whether an object already exists at the new
        path. Both paths are in the original namespace. If it returns
        ``false`` it should set the string to the reason why the edit isn't
        allowed. It should not write either path to the string.

        If ``hasObjectAtPath`` is invalid then this assumes objects exist
        where they should and don't exist where they shouldn't. Use this with
        care. If ``canEdit`` in invalid then it's assumed all edits are valid.

        If ``fixBackpointers`` is ``true`` then target/connection paths are
        expected to be in the intermediate namespace resulting from all
        previous edits. If ``false`` and any current or new path contains a
        target or connection path that has been edited then this will generate
        an error.

        This method returns ``true`` if the edits are allowed and sets
        ``processedEdits`` to a new edit sequence at least as efficient as the
        input sequence. If not allowed it returns ``false`` and appends
        reasons why not to ``details`` .


        Parameters
        ----------
        processedEdits : list[SdfNamespaceEdit]

        hasObjectAtPath : HasObjectAtPath

        canEdit : CanEdit

        details : list[SdfNamespaceEditDetail]

        fixBackpointers : bool
        """
    @property
    def edits(self) -> None:
        """
        type : list[SdfNamespaceEdit]


        Returns the edits.

        :type: None
        """
    pass
class ChangeBlock(Boost.Python.instance):
    """
    **DANGER DANGER DANGER**

    Please make sure you have read and fully understand the issues below
    before using a changeblock! They are very easy to use in an unsafe way
    that could make the system crash or corrupt data. If you have any
    questions, please contact the USD team, who would be happy to help!

    SdfChangeBlock provides a way to group a round of related changes to
    scene description in order to process them more efficiently.

    Normally, Sdf sends notification immediately as changes are made so
    that downstream representations like UsdStage can update accordingly.

    However, sometimes it can be advantageous to group a series of Sdf
    changes into a batch so that they can be processed more efficiently,
    with a single round of change processing. An example might be when
    setting many avar values on a model at the same time.

    Opening a changeblock tells Sdf to delay sending notification about
    changes until the outermost changeblock is exited. Until then, Sdf
    internally queues up the notification it needs to send.

    It is *not* safe to use Usd or other downstream API while a
    changeblock is open!! This is because those derived representations
    will not have had a chance to update while the changeblock is open.
    Not only will their view of the world be stale, it could be unsafe to
    even make queries from, since they may be holding onto expired handles
    to Sdf objects that no longer exist. If you need to make a bunch of
    changes to scene description, the best approach is to build a list of
    necessary changes that can be performed directly via the Sdf API, then
    submit those all inside a changeblock without talking to any
    downstream modules. For example, this is how many mutators in Usd
    that operate on more than one field or Spec work.
    """
    __instance_size__ = 32
    pass
class ChildrenView_Sdf_AttributeChildPolicy_SdfAttributeViewPredicate(Boost.Python.instance):
    class ChildrenView_Sdf_AttributeChildPolicy_SdfAttributeViewPredicate_Iterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_AttributeChildPolicy_SdfAttributeViewPredicate_KeyIterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_AttributeChildPolicy_SdfAttributeViewPredicate_ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    pass
class ChildrenView_Sdf_AttributeChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfAttributeSpec___(Boost.Python.instance):
    class ChildrenView_Sdf_AttributeChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfAttributeSpec____Iterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_AttributeChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfAttributeSpec____KeyIterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_AttributeChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfAttributeSpec____ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    pass
class ChildrenView_Sdf_PrimChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPrimSpec___(Boost.Python.instance):
    class ChildrenView_Sdf_PrimChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPrimSpec____Iterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_PrimChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPrimSpec____KeyIterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_PrimChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPrimSpec____ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    pass
class ChildrenView_Sdf_PropertyChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPropertySpec___(Boost.Python.instance):
    class ChildrenView_Sdf_PropertyChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPropertySpec____Iterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_PropertyChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPropertySpec____KeyIterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_PropertyChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfPropertySpec____ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    pass
class ChildrenView_Sdf_RelationshipChildPolicy_SdfRelationshipViewPredicate(Boost.Python.instance):
    class ChildrenView_Sdf_RelationshipChildPolicy_SdfRelationshipViewPredicate_Iterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_RelationshipChildPolicy_SdfRelationshipViewPredicate_KeyIterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_RelationshipChildPolicy_SdfRelationshipViewPredicate_ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    pass
class ChildrenView_Sdf_VariantChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSpec___(Boost.Python.instance):
    class ChildrenView_Sdf_VariantChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSpec____Iterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_VariantChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSpec____KeyIterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_VariantChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSpec____ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    pass
class ChildrenView_Sdf_VariantSetChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSetSpec___(Boost.Python.instance):
    class ChildrenView_Sdf_VariantSetChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSetSpec____Iterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_VariantSetChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSetSpec____KeyIterator(Boost.Python.instance):
        pass
    class ChildrenView_Sdf_VariantSetChildPolicy_SdfChildrenViewTrivialPredicate_SdfHandle_SdfVariantSetSpec____ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    pass
class CleanupEnabler(Boost.Python.instance):
    """
    An RAII class which, when an instance is alive, enables scheduling of
    automatic cleanup of SdfLayers.

    Any affected specs which no longer contribute to the scene will be
    removed when the last SdfCleanupEnabler instance goes out of scope.
    Note that for this purpose, SdfPropertySpecs are removed if they have
    only required fields (see SdfPropertySpecs::HasOnlyRequiredFields),
    but only if the property spec itself was affected by an edit that left
    it with only required fields. This will have the effect of
    uninstantiating on-demand attributes. For example, if its parent prim
    was affected by an edit that left it otherwise inert, it will not be
    removed if it contains an SdfPropertySpec with only required fields,
    but if the property spec itself is edited leaving it with only
    required fields, it will be removed, potentially uninstantiating it if
    it's an on-demand property.

    SdfCleanupEnablers are accessible in both C++ and Python.

    /// SdfCleanupEnabler can be used in the following manner:

    .. code-block:: text

      {
          SdfCleanupEnabler enabler;
          
          // Perform any action that might otherwise leave inert specs around, 
          // such as removing info from properties or prims, or removing name 
          // children. i.e:
          primSpec->ClearInfo(SdfFieldKeys->Default);
      
          // When enabler goes out of scope on the next line, primSpec will 
          // be removed if it has been left as an empty over.
      }
    """
    __instance_size__ = 24
    pass
class DimensionlessUnit(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.DimensionlessUnitPercent, Sdf.DimensionlessUnitDefault)
    pass
class FastUpdateList(Boost.Python.instance):
    class FastUpdate(Boost.Python.instance):
        @property
        def path(self) -> None:
            """
            :type: None
            """
        @property
        def value(self) -> None:
            """
            :type: None
            """
        pass
    @property
    def fastUpdates(self) -> None:
        """
        :type: None
        """
    @property
    def hasCompositionDependents(self) -> None:
        """
        :type: None
        """
    pass
class FileFormat(Boost.Python.instance):
    """
    Base class for file format implementations.
    """
    class Tokens(Boost.Python.instance):
        TargetArg = 'target'
        pass
    @staticmethod
    def CanRead(file) -> bool: 
        """
        CanRead(file) -> bool


        Returns true if ``file`` can be read by this format.


        Parameters
        ----------
        file : str
        """
    @staticmethod
    def FindAllFileFormatExtensions(*args, **kwargs) -> None: 
        """
        **classmethod** FindAllFileFormatExtensions() -> set[str]


        Returns a set containing the extension(s) corresponding to all
        registered file formats.
        """
    @staticmethod
    def FindByExtension(path, args) -> FileFormat: 
        """
        **classmethod** FindByExtension(path, target) -> FileFormat


        Returns the file format instance that supports the extension for
        ``path`` .


        If a format with a matching extension is not found, this returns a
        null file format pointer.

        An extension may be handled by multiple file formats, but each with a
        different target. In such cases, if no ``target`` is specified, the
        file format that is registered as the primary plugin will be returned.
        Otherwise, the file format whose target matches ``target`` will be
        returned.


        Parameters
        ----------
        path : str

        target : str



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


        Returns a file format instance that supports the extension for
        ``path`` and whose target matches one of those specified by the given
        ``args`` .


        If the ``args`` specify no target, then the file format that is
        registered as the primary plugin will be returned. If a format with a
        matching extension is not found, this returns a null file format
        pointer.


        Parameters
        ----------
        path : str

        args : FileFormatArguments
        """
    @staticmethod
    def FindById(*args, **kwargs) -> None: 
        """
        **classmethod** FindById(formatId) -> FileFormat


        Returns the file format instance with the specified ``formatId``
        identifier.


        If a format with a matching identifier is not found, this returns a
        null file format pointer.


        Parameters
        ----------
        formatId : str
        """
    @staticmethod
    def GetFileExtension(*args, **kwargs) -> None: 
        """
        **classmethod** GetFileExtension(s) -> str


        Returns the file extension for path or file name ``s`` , without the
        leading dot character.


        Parameters
        ----------
        s : str
        """
    @staticmethod
    def GetFileExtensions() -> list[str]: 
        """
        GetFileExtensions() -> list[str]


        Returns a list of extensions that this format supports.
        """
    @staticmethod
    def IsPackage() -> bool: 
        """
        IsPackage() -> bool


        Returns true if this file format is a package containing other assets.
        """
    @staticmethod
    def IsSupportedExtension(extension) -> bool: 
        """
        IsSupportedExtension(extension) -> bool


        Returns true if ``extension`` matches one of the extensions returned
        by GetFileExtensions.


        Parameters
        ----------
        extension : str
        """
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

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


        Returns the cookie to be used when writing files with this format.

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


        Returns the format identifier.

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


        Returns the primary file extension for this format.


        This is the extension that is reported for layers using this file
        format.

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


        Returns the target for this file format.

        :type: None
        """
    pass
class Int64ListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class IntListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class Layer(Boost.Python.instance):
    """
    A scene description container that can combine with other such
    containers to form simple component assets, and successively larger
    aggregates. The contents of an SdfLayer adhere to the SdfData data
    model. A layer can be ephemeral, or be an asset accessed and
    serialized through the ArAsset and ArResolver interfaces.

    The SdfLayer class provides a consistent API for accesing and
    serializing scene description, using any data store provided by Ar
    plugins. Sdf itself provides a UTF-8 text format for layers identified
    by the".sdf"identifier extension, but via the SdfFileFormat
    abstraction, allows downstream modules and plugins to adapt arbitrary
    data formats to the SdfData/SdfLayer model.

    The FindOrOpen() method returns a new SdfLayer object with scene
    description from any supported asset format. Once read, a layer
    remembers which asset it was read from. The Save() method saves the
    layer back out to the original asset. You can use the Export() method
    to write the layer to a different location. You can use the
    GetIdentifier() method to get the layer's Id or GetRealPath() to get
    the resolved, full URI.

    Layers can have a timeCode range (startTimeCode and endTimeCode). This
    range represents the suggested playback range, but has no impact on
    the extent of the animation data that may be stored in the layer. The
    metadatum"timeCodesPerSecond"is used to annotate how the time ordinate
    for samples contained in the file scales to seconds. For example, if
    timeCodesPerSecond is 24, then a sample at time ordinate 24 should be
    viewed exactly one second after the sample at time ordinate 0.
    """
    class DetachedLayerRules(Boost.Python.instance):
        @staticmethod
        def Exclude(*args, **kwargs) -> None: ...
        @staticmethod
        def GetExcluded(*args, **kwargs) -> None: ...
        @staticmethod
        def GetIncluded(*args, **kwargs) -> None: ...
        @staticmethod
        def Include(*args, **kwargs) -> None: ...
        @staticmethod
        def IncludeAll(*args, **kwargs) -> None: ...
        @staticmethod
        def IncludedAll(*args, **kwargs) -> None: ...
        @staticmethod
        def IsIncluded(*args, **kwargs) -> None: ...
        __instance_size__ = 72
        pass
    @staticmethod
    def AddToMutedLayers(*args, **kwargs) -> None: 
        """
        **classmethod** AddToMutedLayers(mutedPath) -> None


        Add the specified path to the muted layers set.


        Parameters
        ----------
        mutedPath : str
        """
    @staticmethod
    def Apply(arg1) -> bool: 
        """
        Apply(arg1) -> bool


        Performs a batch of namespace edits.


        Returns ``true`` on success and ``false`` on failure. On failure, no
        namespace edits will have occurred.


        Parameters
        ----------
        arg1 : BatchNamespaceEdit
        """
    @staticmethod
    def ApplyRootPrimOrder(vec) -> None: 
        """
        ApplyRootPrimOrder(vec) -> None


        Reorders the given list of prim names according to the reorder
        rootPrims statement for this layer.


        This routine employs the standard list editing operations for ordered
        items in a ListEditor.


        Parameters
        ----------
        vec : list[str]
        """
    @staticmethod
    def CanApply(arg1, details) -> NamespaceEditDetail.Result: 
        """
        CanApply(arg1, details) -> NamespaceEditDetail.Result


        Check if a batch of namespace edits will succeed.


        This returns ``SdfNamespaceEditDetail::Okay`` if they will succeed as
        a batch, ``SdfNamespaceEditDetail::Unbatched`` if the edits will
        succeed but will be applied unbatched, and
        ``SdfNamespaceEditDetail::Error`` if they will not succeed. No edits
        will be performed in any case.

        If ``details`` is not ``None`` and the method does not return ``Okay``
        then details about the problems will be appended to ``details`` . A
        problem may cause the method to return early, so ``details`` may not
        list every problem.

        Note that Sdf does not track backpointers so it's unable to fix up
        targets/connections to namespace edited objects. Clients must fix
        those to prevent them from falling off. In addition, this method will
        report failure if any relational attribute with a target to a
        namespace edited object is subsequently edited (in the same batch).
        Clients should perform edits on relational attributes first.

        Clients may wish to report unbatch details to the user to confirm that
        the edits should be applied unbatched. This will give the user a
        chance to correct any problems that cause batching to fail and try
        again.


        Parameters
        ----------
        arg1 : BatchNamespaceEdit

        details : list[SdfNamespaceEditDetail]
        """
    @staticmethod
    def Clear() -> None: 
        """
        Clear() -> None


        Clears the layer of all content.


        This restores the layer to a state as if it had just been created with
        CreateNew() . This operation is Undo-able.

        The fileName and whether journaling is enabled are not affected by
        this method.
        """
    @staticmethod
    def ClearColorConfiguration() -> None: 
        """
        ClearColorConfiguration() -> None


        Clears the color configuration metadata authored in this layer.
        """
    @staticmethod
    def ClearColorManagementSystem() -> None: 
        """
        ClearColorManagementSystem() -> None


        Clears the'colorManagementSystem'metadata authored in this layer.
        """
    @staticmethod
    def ClearCustomLayerData() -> None: 
        """
        ClearCustomLayerData() -> None


        Clears out the CustomLayerData dictionary associated with this layer.
        """
    @staticmethod
    def ClearDefaultPrim() -> None: 
        """
        ClearDefaultPrim() -> None


        Clear the default prim metadata for this layer.


        See GetDefaultPrim() and SetDefaultPrim() .
        """
    @staticmethod
    def ClearEndTimeCode() -> None: 
        """
        ClearEndTimeCode() -> None


        Clear the endTimeCode opinion.
        """
    @staticmethod
    def ClearFramePrecision() -> None: 
        """
        ClearFramePrecision() -> None


        Clear the framePrecision opinion.
        """
    @staticmethod
    def ClearFramesPerSecond() -> None: 
        """
        ClearFramesPerSecond() -> None


        Clear the framesPerSecond opinion.
        """
    @staticmethod
    def ClearOwner() -> None: 
        """
        ClearOwner() -> None


        Clear the owner opinion.
        """
    @staticmethod
    def ClearSessionOwner() -> None: 
        """
        ClearSessionOwner() -> None
        """
    @staticmethod
    def ClearStartTimeCode() -> None: 
        """
        ClearStartTimeCode() -> None


        Clear the startTimeCode opinion.
        """
    @staticmethod
    def ClearTimeCodesPerSecond() -> None: 
        """
        ClearTimeCodesPerSecond() -> None


        Clear the timeCodesPerSecond opinion.
        """
    @staticmethod
    def ComputeAbsolutePath(assetPath) -> str: 
        """
        ComputeAbsolutePath(assetPath) -> str


        Returns the path to the asset specified by ``assetPath`` using this
        layer to anchor the path if necessary.


        Returns ``assetPath`` if it's empty or an anonymous layer identifier.

        This method can be used on asset paths that are authored in this layer
        to create new asset paths that can be copied to other layers. These
        new asset paths should refer to the same assets as the original asset
        paths. For example, if the underlying ArResolver is filesystem-based
        and ``assetPath`` is a relative filesystem path, this method might
        return the absolute filesystem path using this layer's location as the
        anchor.

        The returned path should in general not be assumed to be an absolute
        filesystem path or any other specific form. It is"absolute"in that it
        should resolve to the same asset regardless of what layer it's
        authored in.


        Parameters
        ----------
        assetPath : str
        """
    @staticmethod
    def CreateAnonymous(tag, format, args) -> Layer: 
        """
        **classmethod** CreateAnonymous(tag, args) -> Layer


        Creates a new *anonymous* layer with an optional ``tag`` .


        An anonymous layer is a layer with a system assigned identifier, that
        cannot be saved to disk via Save() . Anonymous layers have an
        identifier, but no real path or other asset information fields.

        Anonymous layers may be tagged, which can be done to aid debugging
        subsystems that make use of anonymous layers. The tag becomes the
        display name of an anonymous layer, and is also included in the
        generated identifier. Untagged anonymous layers have an empty display
        name.

        Additional arguments may be supplied via the ``args`` parameter. These
        arguments may control behavior specific to the layer's file format.


        Parameters
        ----------
        tag : str

        args : FileFormatArguments



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


        Create an anonymous layer with a specific ``format`` .


        Parameters
        ----------
        tag : str

        format : FileFormat

        args : FileFormatArguments
        """
    @staticmethod
    def CreateIdentifier(*args, **kwargs) -> None: 
        """
        **classmethod** CreateIdentifier(layerPath, arguments) -> str


        Joins the given layer path and arguments into an identifier.


        Parameters
        ----------
        layerPath : str

        arguments : FileFormatArguments
        """
    @staticmethod
    def CreateNew(fileFormat, identifier, args) -> Layer: 
        """
        **classmethod** CreateNew(identifier, args) -> Layer


        Creates a new empty layer with the given identifier.


        Additional arguments may be supplied via the ``args`` parameter. These
        arguments may control behavior specific to the layer's file format.


        Parameters
        ----------
        identifier : str

        args : FileFormatArguments



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


        Creates a new empty layer with the given identifier for a given file
        format class.


        This function has the same behavior as the other CreateNew function,
        but uses the explicitly-specified ``fileFormat`` instead of attempting
        to discern the format from ``identifier`` .


        Parameters
        ----------
        fileFormat : FileFormat

        identifier : str

        args : FileFormatArguments
        """
    @staticmethod
    def DumpLayerInfo(*args, **kwargs) -> None: 
        """
        Debug helper to examine content of the current layer registry and
        the asset/real path of all layers in the registry.
        """
    @staticmethod
    def EraseTimeSample(path, time) -> None: 
        """
        EraseTimeSample(path, time) -> None


        Parameters
        ----------
        path : Path

        time : float
        """
    @staticmethod
    def Export(filename, comment, args) -> bool: 
        """
        Export(filename, comment, args) -> bool


        Exports this layer to a file.


        Returns ``true`` if successful, ``false`` if an error occurred.

        If ``comment`` is not empty, the layer gets exported with the given
        comment. Additional arguments may be supplied via the ``args``
        parameter. These arguments may control behavior specific to the
        exported layer's file format.

        Note that the file name or comment of the original layer is not
        updated. This only saves a copy of the layer to the given filename.
        Subsequent calls to Save() will still save the layer to it's
        previously remembered file name.


        Parameters
        ----------
        filename : str

        comment : str

        args : FileFormatArguments
        """
    @staticmethod
    def ExportToString(*args, **kwargs) -> None: 
        """
        Returns the string representation of the layer.
        """
    @staticmethod
    def Find(filename) -> LayerPtr: 
        """
        filename : string

        Returns the open layer with the given filename, or None.  Note that this is a static class method.
        """
    @staticmethod
    def FindOrOpen(*args, **kwargs) -> None: 
        """
        **classmethod** FindOrOpen(identifier, args) -> Layer


        Return an existing layer with the given ``identifier`` and ``args`` ,
        or else load it.


        If the layer can't be found or loaded, an error is posted and a null
        layer is returned.

        Arguments in ``args`` will override any arguments specified in
        ``identifier`` .


        Parameters
        ----------
        identifier : str

        args : FileFormatArguments
        """
    @staticmethod
    def FindOrOpenRelativeToLayer(*args, **kwargs) -> None: 
        """
        **classmethod** FindOrOpenRelativeToLayer(anchor, identifier, args) -> Layer


        Return an existing layer with the given ``identifier`` and ``args`` ,
        or else load it.


        The given ``identifier`` will be resolved relative to the ``anchor``
        layer. If the layer can't be found or loaded, an error is posted and a
        null layer is returned.

        If the ``anchor`` layer is invalid, issues a coding error and returns
        a null handle.

        Arguments in ``args`` will override any arguments specified in
        ``identifier`` .


        Parameters
        ----------
        anchor : Layer

        identifier : str

        args : FileFormatArguments
        """
    @staticmethod
    def FindRelativeToLayer(*args, **kwargs) -> None: 
        """
        Returns the open layer with the given filename, or None.  If the filename is a relative path then it's found relative to the given layer.  Note that this is a static class method.
        """
    @staticmethod
    def GetAssetInfo() -> VtValue: 
        """
        GetAssetInfo() -> VtValue


        Returns resolve information from the last time the layer identifier
        was resolved.
        """
    @staticmethod
    def GetAssetName() -> str: 
        """
        GetAssetName() -> str


        Returns the asset name associated with this layer.
        """
    @staticmethod
    def GetAttributeAtPath(path) -> AttributeSpec: 
        """
        GetAttributeAtPath(path) -> AttributeSpec


        Returns an attribute at the given ``path`` .


        Returns ``None`` if there is no attribute at ``path`` . This is simply
        a more specifically typed version of ``GetObjectAtPath()`` .


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetBracketingTimeSamples(time, tLower, tUpper) -> bool: 
        """
        GetBracketingTimeSamples(time, tLower, tUpper) -> bool


        Parameters
        ----------
        time : float

        tLower : float

        tUpper : float
        """
    @staticmethod
    def GetBracketingTimeSamplesForPath(path, time, tLower, tUpper) -> bool: 
        """
        GetBracketingTimeSamplesForPath(path, time, tLower, tUpper) -> bool


        Parameters
        ----------
        path : Path

        time : float

        tLower : float

        tUpper : float
        """
    @staticmethod
    def GetCompositionAssetDependencies() -> set[str]: 
        """
        GetCompositionAssetDependencies() -> set[str]


        Return paths of all assets this layer depends on due to composition
        fields.


        This includes the paths of all layers referred to by reference,
        payload, and sublayer fields in this layer. This function only returns
        direct composition dependencies of this layer, i.e. it does not
        recurse to find composition dependencies from its dependent layer
        assets.
        """
    @staticmethod
    def GetDetachedLayerRules(*args, **kwargs) -> None: 
        """
        **classmethod** GetDetachedLayerRules() -> DetachedLayerRules


        Returns the current rules for the detached layer set.
        """
    @staticmethod
    def GetDisplayName() -> str: 
        """
        GetDisplayName() -> str


        Returns the layer's display name.


        The display name is the base filename of the identifier.
        """
    @staticmethod
    def GetDisplayNameFromIdentifier(*args, **kwargs) -> None: 
        """
        **classmethod** GetDisplayNameFromIdentifier(identifier) -> str


        Returns the display name for the given ``identifier`` , using the same
        rules as GetDisplayName.


        Parameters
        ----------
        identifier : str
        """
    @staticmethod
    def GetExternalAssetDependencies() -> set[str]: 
        """
        GetExternalAssetDependencies() -> set[str]


        Returns a set of resolved paths to all external asset dependencies the
        layer needs to generate its contents.


        These are additional asset dependencies that are determined by the
        layer's file format and will be consulted during Reload() when
        determining if the layer needs to be reloaded. This specifically does
        not include dependencies related to composition, i.e. this will not
        include assets from references, payloads, and sublayers.
        """
    @staticmethod
    def GetExternalReferences(*args, **kwargs) -> None: 
        """
        Return a list of asset paths for
        this layer.
        """
    @staticmethod
    def GetFileFormat() -> FileFormat: 
        """
        GetFileFormat() -> FileFormat


        Returns the file format used by this layer.
        """
    @staticmethod
    def GetFileFormatArguments() -> FileFormatArguments: 
        """
        GetFileFormatArguments() -> FileFormatArguments


        Returns the file format-specific arguments used during the
        construction of this layer.
        """
    @staticmethod
    def GetLoadedLayers(*args, **kwargs) -> None: 
        """
        Return list of loaded layers.
        """
    @staticmethod
    def GetMutedLayers(*args, **kwargs) -> None: 
        """
        Return list of muted layers.
        """
    @staticmethod
    def GetNumTimeSamplesForPath(path) -> int: 
        """
        GetNumTimeSamplesForPath(path) -> int


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetObjectAtPath(path) -> Spec: 
        """
        GetObjectAtPath(path) -> Spec


        Returns the object at the given ``path`` .


        There is no distinction between an absolute and relative path at the
        SdLayer level.

        Returns ``None`` if there is no object at ``path`` .


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetPrimAtPath(path) -> PrimSpec: 
        """
        GetPrimAtPath(path) -> PrimSpec


        Returns the prim at the given ``path`` .


        Returns ``None`` if there is no prim at ``path`` . This is simply a
        more specifically typed version of ``GetObjectAtPath()`` .


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetPropertyAtPath(path) -> PropertySpec: 
        """
        GetPropertyAtPath(path) -> PropertySpec


        Returns a property at the given ``path`` .


        Returns ``None`` if there is no property at ``path`` . This is simply
        a more specifically typed version of ``GetObjectAtPath()`` .


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetRelationshipAtPath(path) -> RelationshipSpec: 
        """
        GetRelationshipAtPath(path) -> RelationshipSpec


        Returns a relationship at the given ``path`` .


        Returns ``None`` if there is no relationship at ``path`` . This is
        simply a more specifically typed version of ``GetObjectAtPath()`` .


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def HasColorConfiguration() -> bool: 
        """
        HasColorConfiguration() -> bool


        Returns true if color configuration metadata is set in this layer.
        """
    @staticmethod
    def HasColorManagementSystem() -> bool: 
        """
        HasColorManagementSystem() -> bool


        Returns true if colorManagementSystem metadata is set in this layer.
        """
    @staticmethod
    def HasCustomLayerData() -> bool: 
        """
        HasCustomLayerData() -> bool


        Returns true if CustomLayerData is authored on the layer.
        """
    @staticmethod
    def HasDefaultPrim() -> bool: 
        """
        HasDefaultPrim() -> bool


        Return true if the default prim metadata is set in this layer.


        See GetDefaultPrim() and SetDefaultPrim() .
        """
    @staticmethod
    def HasEndTimeCode() -> bool: 
        """
        HasEndTimeCode() -> bool


        Returns true if the layer has an endTimeCode opinion.
        """
    @staticmethod
    def HasFramePrecision() -> bool: 
        """
        HasFramePrecision() -> bool


        Returns true if the layer has a frames precision opinion.
        """
    @staticmethod
    def HasFramesPerSecond() -> bool: 
        """
        HasFramesPerSecond() -> bool


        Returns true if the layer has a frames per second opinion.
        """
    @staticmethod
    def HasOwner() -> bool: 
        """
        HasOwner() -> bool


        Returns true if the layer has an owner opinion.
        """
    @staticmethod
    def HasSessionOwner() -> bool: 
        """
        HasSessionOwner() -> bool


        Returns true if the layer has a session owner opinion.
        """
    @staticmethod
    def HasStartTimeCode() -> bool: 
        """
        HasStartTimeCode() -> bool


        Returns true if the layer has a startTimeCode opinion.
        """
    @staticmethod
    def HasTimeCodesPerSecond() -> bool: 
        """
        HasTimeCodesPerSecond() -> bool


        Returns true if the layer has a timeCodesPerSecond opinion.
        """
    @staticmethod
    def Import(layerPath) -> bool: 
        """
        Import(layerPath) -> bool


        Imports the content of the given layer path, replacing the content of
        the current layer.


        Note: If the layer path is the same as the current layer's real path,
        no action is taken (and a warning occurs). For this case use Reload()
        .


        Parameters
        ----------
        layerPath : str
        """
    @staticmethod
    def ImportFromString(string) -> bool: 
        """
        ImportFromString(string) -> bool


        Reads this layer from the given string.


        Returns ``true`` if successful, otherwise returns ``false`` .


        Parameters
        ----------
        string : str
        """
    @staticmethod
    def IsAnonymousLayerIdentifier(*args, **kwargs) -> None: 
        """
        **classmethod** IsAnonymousLayerIdentifier(identifier) -> bool


        Returns true if the ``identifier`` is an anonymous layer unique
        identifier.


        Parameters
        ----------
        identifier : str
        """
    @staticmethod
    def IsDetached() -> bool: 
        """
        IsDetached() -> bool


        Returns true if this layer is detached from its serialized data store,
        false otherwise.


        Detached layers are isolated from external changes to their serialized
        data.
        """
    @staticmethod
    def IsIncludedByDetachedLayerRules(*args, **kwargs) -> None: 
        """
        **classmethod** IsIncludedByDetachedLayerRules(identifier) -> bool


        Returns whether the given layer identifier is included in the current
        rules for the detached layer set.


        This is equivalent to GetDetachedLayerRules() .IsIncluded(identifier).


        Parameters
        ----------
        identifier : str
        """
    @staticmethod
    def IsMuted(path) -> bool: 
        """
        **classmethod** IsMuted() -> bool


        Returns ``true`` if the current layer is muted.




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


        Returns ``true`` if the specified layer path is muted.


        Parameters
        ----------
        path : str
        """
    @staticmethod
    def ListAllTimeSamples() -> set[float]: 
        """
        ListAllTimeSamples() -> set[float]
        """
    @staticmethod
    def ListTimeSamplesForPath(path) -> set[float]: 
        """
        ListTimeSamplesForPath(path) -> set[float]


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def New(*args, **kwargs) -> None: 
        """
        **classmethod** New(fileFormat, identifier, args) -> Layer


        Creates a new empty layer with the given identifier for a given file
        format class.


        The new layer will not be dirty and will not be saved.

        Additional arguments may be supplied via the ``args`` parameter. These
        arguments may control behavior specific to the layer's file format.


        Parameters
        ----------
        fileFormat : FileFormat

        identifier : str

        args : FileFormatArguments
        """
    @staticmethod
    def OpenAsAnonymous(*args, **kwargs) -> None: 
        """
        **classmethod** OpenAsAnonymous(layerPath, metadataOnly, tag) -> Layer


        Load the given layer from disk as a new anonymous layer.


        If the layer can't be found or loaded, an error is posted and a null
        layer is returned.

        The anonymous layer does not retain any knowledge of the backing file
        on the filesystem.

        ``metadataOnly`` is a flag that asks for only the layer metadata to be
        read in, which can be much faster if that is all that is required.
        Note that this is just a hint: some FileFormat readers may disregard
        this flag and still fully populate the layer contents.

        An optional ``tag`` may be specified. See CreateAnonymous for details.


        Parameters
        ----------
        layerPath : str

        metadataOnly : bool

        tag : str
        """
    @staticmethod
    @typing.overload
    def QueryTimeSample(path, time, value) -> bool: 
        """
        QueryTimeSample(path, time, value) -> bool


        Parameters
        ----------
        path : Path

        time : float

        value : VtValue



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


        Parameters
        ----------
        path : Path

        time : float

        value : SdfAbstractDataValue



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


        Parameters
        ----------
        path : Path

        time : float

        data : T
        """
    @staticmethod
    @typing.overload
    def QueryTimeSample(path, time, data) -> bool: ...
    @staticmethod
    def Reload(force) -> bool: 
        """
        Reload(force) -> bool


        Reloads the layer from its persistent representation.


        This restores the layer to a state as if it had just been created with
        FindOrOpen() . This operation is Undo-able.

        The fileName and whether journaling is enabled are not affected by
        this method.

        When called with force = false (the default), Reload attempts to avoid
        reloading layers that have not changed on disk. It does so by
        comparing the file's modification time (mtime) to when the file was
        loaded. If the layer has unsaved modifications, this mechanism is not
        used, and the layer is reloaded from disk. If the layer has any
        external asset dependencies their modification state will also be
        consulted when determining if the layer needs to be reloaded.

        Passing true to the ``force`` parameter overrides this behavior,
        forcing the layer to be reloaded from disk regardless of whether it
        has changed.


        Parameters
        ----------
        force : bool
        """
    @staticmethod
    def ReloadLayers(*args, **kwargs) -> None: 
        """
        **classmethod** ReloadLayers(layers, force) -> bool


        Reloads the specified layers.


        Returns ``false`` if one or more layers failed to reload.

        See ``Reload()`` for a description of the ``force`` flag.


        Parameters
        ----------
        layers : set[Layer]

        force : bool
        """
    @staticmethod
    def RemoveFromMutedLayers(*args, **kwargs) -> None: 
        """
        **classmethod** RemoveFromMutedLayers(mutedPath) -> None


        Remove the specified path from the muted layers set.


        Parameters
        ----------
        mutedPath : str
        """
    @staticmethod
    def RemoveInertSceneDescription() -> None: 
        """
        RemoveInertSceneDescription() -> None


        Removes all scene description in this layer that does not affect the
        scene.


        This method walks the layer namespace hierarchy and removes any prims
        and that are not contributing any opinions.
        """
    @staticmethod
    def Save(force) -> bool: 
        """
        Save(force) -> bool


        Returns ``true`` if successful, ``false`` if an error occurred.


        Returns ``false`` if the layer has no remembered file name or the
        layer type cannot be saved. The layer will not be overwritten if the
        file exists and the layer is not dirty unless ``force`` is true.


        Parameters
        ----------
        force : bool
        """
    @staticmethod
    def ScheduleRemoveIfInert(spec) -> None: 
        """
        ScheduleRemoveIfInert(spec) -> None


        Cause ``spec`` to be removed if it no longer affects the scene when
        the last change block is closed, or now if there are no change blocks.


        Parameters
        ----------
        spec : Spec
        """
    @staticmethod
    def SetDetachedLayerRules(*args, **kwargs) -> None: 
        """
        **classmethod** SetDetachedLayerRules(mask) -> None


        Sets the rules specifying detached layers.


        Newly-created or opened layers whose identifiers are included in
        ``rules`` will be opened as detached layers. Existing layers that are
        now included or no longer included will be reloaded. Any unsaved
        modifications to those layers will be lost.

        This function is not thread-safe. It may not be run concurrently with
        any other functions that open, close, or read from any layers.

        The detached layer rules are initially set to exclude all layers. This
        may be overridden by setting the environment variables
        SDF_LAYER_INCLUDE_DETACHED and SDF_LAYER_EXCLUDE_DETACHED to specify
        the initial set of include and exclude patterns in the rules. These
        variables can be set to a comma-delimited list of patterns.
        SDF_LAYER_INCLUDE_DETACHED may also be set to"\*"to include all
        layers. Note that these environment variables only set the initial
        state of the detached layer rules; these values may be overwritten by
        subsequent calls to this function.

        See SdfLayer::DetachedLayerRules::IsIncluded for details on how the
        rules are applied to layer identifiers.


        Parameters
        ----------
        mask : DetachedLayerRules
        """
    @staticmethod
    def SetMuted(muted) -> None: 
        """
        SetMuted(muted) -> None


        Mutes the current layer if ``muted`` is ``true`` , and unmutes it
        otherwise.


        Parameters
        ----------
        muted : bool
        """
    @staticmethod
    def SetPermissionToEdit(allow) -> None: 
        """
        SetPermissionToEdit(allow) -> None


        Sets permission to edit.


        Parameters
        ----------
        allow : bool
        """
    @staticmethod
    def SetPermissionToSave(allow) -> None: 
        """
        SetPermissionToSave(allow) -> None


        Sets permission to save.


        Parameters
        ----------
        allow : bool
        """
    @staticmethod
    def SetTimeSample(path, time, value) -> None: 
        """
        SetTimeSample(path, time, value) -> None


        Parameters
        ----------
        path : Path

        time : float

        value : VtValue



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


        Parameters
        ----------
        path : Path

        time : float

        value : SdfAbstractDataConstValue



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


        Parameters
        ----------
        path : Path

        time : float

        value : T
        """
    @staticmethod
    def SplitIdentifier(*args, **kwargs) -> None: 
        """
        **classmethod** SplitIdentifier(identifier, layerPath, arguments) -> bool


        Splits the given layer identifier into its constituent layer path and
        arguments.


        Parameters
        ----------
        identifier : str

        layerPath : str

        arguments : FileFormatArguments
        """
    @staticmethod
    def StreamsData() -> bool: 
        """
        StreamsData() -> bool


        Returns true if this layer streams data from its serialized data store
        on demand, false otherwise.


        Layers with streaming data are treated differently to avoid pulling in
        data unnecessarily. For example, reloading a streaming layer will not
        perform fine-grained change notification, since doing so would require
        the full contents of the layer to be loaded.
        """
    @staticmethod
    def TransferContent(layer) -> None: 
        """
        TransferContent(layer) -> None


        Copies the content of the given layer into this layer.


        Source layer is unmodified.


        Parameters
        ----------
        layer : Layer
        """
    @staticmethod
    def Traverse(path, func) -> None: 
        """
        Traverse(path, func) -> None


        Parameters
        ----------
        path : Path

        func : TraversalFunction
        """
    @staticmethod
    def UpdateAssetInfo() -> None: 
        """
        UpdateAssetInfo() -> None


        Update layer asset information.


        Calling this method re-resolves the layer identifier, which updates
        asset information such as the layer's resolved path and other asset
        info. This may be used to update the layer after external changes to
        the underlying asset system.
        """
    @staticmethod
    def UpdateCompositionAssetDependency(oldAssetPath, newAssetPath) -> bool: 
        """
        UpdateCompositionAssetDependency(oldAssetPath, newAssetPath) -> bool


        Updates the asset path of a composation dependency in this layer.


        If ``newAssetPath`` is supplied, the update works as"rename", updating
        any occurrence of ``oldAssetPath`` to ``newAssetPath`` in all
        reference, payload, and sublayer fields.

        If ``newAssetPath`` is not given, this update behaves as a"delete",
        removing all occurrences of ``oldAssetPath`` from all reference,
        payload, and sublayer fields.


        Parameters
        ----------
        oldAssetPath : str

        newAssetPath : str
        """
    @staticmethod
    def UpdateExternalReference(oldAssetPath, newAssetPath) -> bool: 
        """
        UpdateExternalReference(oldAssetPath, newAssetPath) -> bool


        Deprecated

        Use UpdateCompositionAssetDependency instead.


        Parameters
        ----------
        oldAssetPath : str

        newAssetPath : str
        """
    @staticmethod
    def _WriteDataFile(*args, **kwargs) -> None: ...
    @property
    def anonymous(self) -> None:
        """
        type : bool


        Returns true if this layer is an anonymous layer.

        :type: None
        """
    @property
    def colorConfiguration(self) -> None:
        """
        The color configuration asset-path of this layer.

        :type: None
        """
    @property
    def colorManagementSystem(self) -> None:
        """
        The name of the color management system used to interpret the colorConfiguration asset.

        :type: None
        """
    @property
    def comment(self) -> None:
        """
        The layer's comment string.

        :type: None
        """
    @property
    def customLayerData(self) -> None:
        """
        The customLayerData dictionary associated with this layer.

        :type: None
        """
    @property
    def defaultPrim(self) -> None:
        """
        The layer's default reference target token.

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


        Returns ``true`` if the layer is dirty, i.e.


        has changed from its persistent representation.

        :type: None
        """
    @property
    def documentation(self) -> None:
        """
        The layer's documentation string.

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


        Returns whether this layer has no significant data.

        :type: None
        """
    @property
    def endTimeCode(self) -> None:
        """
        The end timeCode of this layer.

        The end timeCode of a layer is not a hard limit, but is 
        more of a hint. A layer's time-varying content is not limited to
        the timeCode range of the layer.

        :type: None
        """
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    @property
    def externalReferences(self) -> None:
        """
        Return unique list of asset paths of external references for
        given layer.

        :type: None
        """
    @property
    def fileExtension(self) -> None:
        """
        The layer's file extension.

        :type: None
        """
    @property
    def framePrecision(self) -> None:
        """
        The number of digits of precision used in times in this layer.

        :type: None
        """
    @property
    def framesPerSecond(self) -> None:
        """
        The frames per second used in this layer.

        :type: None
        """
    @property
    def hasOwnedSubLayers(self) -> None:
        """
        Whether this layer's sub layers are expected to have owners.

        :type: None
        """
    @property
    def identifier(self) -> None:
        """
        The layer's identifier.

        :type: None
        """
    @property
    def owner(self) -> None:
        """
        The owner of this layer.

        :type: None
        """
    @property
    def permissionToEdit(self) -> None:
        """
        Return true if permitted to be edited (modified), false otherwise.

        :type: None
        """
    @property
    def permissionToSave(self) -> None:
        """
        Return true if permitted to be saved, false otherwise.

        :type: None
        """
    @property
    def pseudoRoot(self) -> None:
        """
        The pseudo-root of the layer.

        :type: None
        """
    @property
    def realPath(self) -> None:
        """
        The layer's resolved path.

        :type: None
        """
    @property
    def repositoryPath(self) -> None:
        """
        The layer's associated repository path

        :type: None
        """
    @property
    def resolvedPath(self) -> None:
        """
        The layer's resolved path.

        :type: None
        """
    @property
    def rootPrimOrder(self) -> None:
        """
        Get/set the list of root prim names for this layer's 'reorder rootPrims' statement.

        :type: None
        """
    @property
    def rootPrims(self) -> None:
        """
        The root prims of this layer, as an ordered dictionary.

        The prims may be accessed by index or by name.
        Although this property claims it is read only, you can modify the contents of this dictionary to add, remove, or reorder the contents.

        :type: None
        """
    @property
    def sessionOwner(self) -> None:
        """
        The session owner of this layer. Only intended for use with session layers.

        :type: None
        """
    @property
    def startTimeCode(self) -> None:
        """
        The start timeCode of this layer.

        The start timeCode of a layer is not a hard limit, but is 
        more of a hint.  A layer's time-varying content is not limited to 
        the timeCode range of the layer.

        :type: None
        """
    @property
    def subLayerOffsets(self) -> None:
        """
        The sublayer offsets of this layer, as a list.  Although this property is claimed to be read only, you can modify the contents of this list by assigning new layer offsets to specific indices.

        :type: None
        """
    @property
    def subLayerPaths(self) -> None:
        """
        The sublayer paths of this layer, as a list.  Although this property is claimed to be read only, you can modify the contents of this list.

        :type: None
        """
    @property
    def timeCodesPerSecond(self) -> None:
        """
        The timeCodes per second used in this layer.

        :type: None
        """
    @property
    def version(self) -> None:
        """
        The layer's version.

        :type: None
        """
    ColorConfigurationKey = 'colorConfiguration'
    ColorManagementSystemKey = 'colorManagementSystem'
    CommentKey = 'comment'
    DocumentationKey = 'documentation'
    EndFrameKey = 'endFrame'
    EndTimeCodeKey = 'endTimeCode'
    FramePrecisionKey = 'framePrecision'
    FramesPerSecondKey = 'framesPerSecond'
    HasOwnedSubLayers = 'hasOwnedSubLayers'
    OwnerKey = 'owner'
    SessionOwnerKey = 'sessionOwner'
    StartFrameKey = 'startFrame'
    StartTimeCodeKey = 'startTimeCode'
    TimeCodesPerSecondKey = 'timeCodesPerSecond'
    pass
class LayerOffset(Boost.Python.instance):
    """
    Represents a time offset and scale between layers.

    The SdfLayerOffset class is an affine transform, providing both a
    scale and a translate. It supports vector algebra semantics for
    composing SdfLayerOffsets together via multiplication. The
    SdfLayerOffset class is unitless: it does not refer to seconds or
    frames.

    For example, suppose layer A uses layer B, with an offset of X:  when
    bringing animation from B into A, you first apply the scale of X, and
    then the offset. Suppose you have a scale of 2 and an offset of 24:
    first multiply B's frame numbers by 2, and then add 24. The animation
    from B as seen in A will take twice as long and start 24 frames later.

    Offsets are typically used in either sublayers or prim references. For
    more information, see the SetSubLayerOffset() method of the SdfLayer
    class (the subLayerOffsets property in Python), as well as the
    SetReference() and GetReferenceLayerOffset() methods (the latter is
    the referenceLayerOffset property in Python) of the SdfPrimSpec class.
    """
    @staticmethod
    def GetInverse() -> LayerOffset: 
        """
        GetInverse() -> LayerOffset


        Gets the inverse offset, which performs the opposite transformation.
        """
    @staticmethod
    def IsIdentity() -> bool: 
        """
        IsIdentity() -> bool


        Returns ``true`` if this is an identity transformation, with an offset
        of 0.0 and a scale of 1.0.
        """
    @property
    def offset(self) -> None:
        """
        type : None


        Sets the time offset.

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

        type : float


        Returns the time offset.

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


        Sets the time scale factor.

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

        type : float


        Returns the time scale factor.

        :type: None
        """
    __instance_size__ = 32
    pass
class LayerTree(Boost.Python.instance):
    """
    A SdfLayerTree is an immutable tree structure representing a sublayer
    stack and its recursive structure.

    Layers can have sublayers, which can in turn have sublayers of their
    own. Clients that want to represent that hierarchical structure in
    memory can build a SdfLayerTree for that purpose.

    We use TfRefPtr<SdfLayerTree> as handles to LayerTrees, as a simple
    way to pass them around as immutable trees without worrying about
    lifetime.
    """
    @property
    def childTrees(self) -> None:
        """
        type : list[SdfLayerTreeHandle]


        Returns the children of this tree node.

        :type: None
        """
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    @property
    def layer(self) -> None:
        """
        type : Layer


        Returns the layer handle this tree node represents.

        :type: None
        """
    @property
    def offset(self) -> None:
        """
        type : LayerOffset


        Returns the cumulative layer offset from the root of the tree.

        :type: None
        """
    pass
class LengthUnit(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.LengthUnitMillimeter, Sdf.LengthUnitCentimeter, Sdf.LengthUnitDecimeter, Sdf.LengthUnitMeter, Sdf.LengthUnitKilometer, Sdf.LengthUnitInch, Sdf.LengthUnitFoot, Sdf.LengthUnitYard, Sdf.LengthUnitMile)
    pass
class ListEditorProxy_SdfNameKeyPolicy(Boost.Python.instance):
    @staticmethod
    def Add(*args, **kwargs) -> None: ...
    @staticmethod
    def Append(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEditsAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def ContainsItemEdit(*args, **kwargs) -> None: ...
    @staticmethod
    def CopyItems(*args, **kwargs) -> None: ...
    @staticmethod
    def Erase(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def ModifyItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def Prepend(*args, **kwargs) -> None: ...
    @staticmethod
    def Remove(*args, **kwargs) -> None: ...
    @staticmethod
    def RemoveItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ReplaceItemEdits(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExpired(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def isOrderedOnly(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    pass
class ListEditorProxy_SdfPathKeyPolicy(Boost.Python.instance):
    @staticmethod
    def Add(*args, **kwargs) -> None: ...
    @staticmethod
    def Append(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEditsAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def ContainsItemEdit(*args, **kwargs) -> None: ...
    @staticmethod
    def CopyItems(*args, **kwargs) -> None: ...
    @staticmethod
    def Erase(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def ModifyItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def Prepend(*args, **kwargs) -> None: ...
    @staticmethod
    def Remove(*args, **kwargs) -> None: ...
    @staticmethod
    def RemoveItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ReplaceItemEdits(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExpired(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def isOrderedOnly(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    pass
class ListEditorProxy_SdfPayloadTypePolicy(Boost.Python.instance):
    @staticmethod
    def Add(*args, **kwargs) -> None: ...
    @staticmethod
    def Append(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEditsAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def ContainsItemEdit(*args, **kwargs) -> None: ...
    @staticmethod
    def CopyItems(*args, **kwargs) -> None: ...
    @staticmethod
    def Erase(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def ModifyItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def Prepend(*args, **kwargs) -> None: ...
    @staticmethod
    def Remove(*args, **kwargs) -> None: ...
    @staticmethod
    def RemoveItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ReplaceItemEdits(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExpired(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def isOrderedOnly(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    pass
class ListEditorProxy_SdfReferenceTypePolicy(Boost.Python.instance):
    @staticmethod
    def Add(*args, **kwargs) -> None: ...
    @staticmethod
    def Append(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearEditsAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def ContainsItemEdit(*args, **kwargs) -> None: ...
    @staticmethod
    def CopyItems(*args, **kwargs) -> None: ...
    @staticmethod
    def Erase(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def ModifyItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def Prepend(*args, **kwargs) -> None: ...
    @staticmethod
    def Remove(*args, **kwargs) -> None: ...
    @staticmethod
    def RemoveItemEdits(*args, **kwargs) -> None: ...
    @staticmethod
    def ReplaceItemEdits(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExpired(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def isOrderedOnly(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    pass
class ListOpType(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.ListOpTypeExplicit, Sdf.ListOpTypeAdded, Sdf.ListOpTypePrepended, Sdf.ListOpTypeAppended, Sdf.ListOpTypeDeleted, Sdf.ListOpTypeOrdered)
    pass
class ListProxy_SdfNameKeyPolicy(Boost.Python.instance):
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyList(*args, **kwargs) -> None: ...
    @staticmethod
    def append(*args, **kwargs) -> None: ...
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def count(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def insert(*args, **kwargs) -> None: ...
    @staticmethod
    def remove(*args, **kwargs) -> None: ...
    @staticmethod
    def replace(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    pass
class ListProxy_SdfNameTokenKeyPolicy(Boost.Python.instance):
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyList(*args, **kwargs) -> None: ...
    @staticmethod
    def append(*args, **kwargs) -> None: ...
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def count(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def insert(*args, **kwargs) -> None: ...
    @staticmethod
    def remove(*args, **kwargs) -> None: ...
    @staticmethod
    def replace(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    pass
class ListProxy_SdfPathKeyPolicy(Boost.Python.instance):
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyList(*args, **kwargs) -> None: ...
    @staticmethod
    def append(*args, **kwargs) -> None: ...
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def count(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def insert(*args, **kwargs) -> None: ...
    @staticmethod
    def remove(*args, **kwargs) -> None: ...
    @staticmethod
    def replace(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    pass
class ListProxy_SdfPayloadTypePolicy(Boost.Python.instance):
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyList(*args, **kwargs) -> None: ...
    @staticmethod
    def append(*args, **kwargs) -> None: ...
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def count(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def insert(*args, **kwargs) -> None: ...
    @staticmethod
    def remove(*args, **kwargs) -> None: ...
    @staticmethod
    def replace(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    pass
class ListProxy_SdfReferenceTypePolicy(Boost.Python.instance):
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyList(*args, **kwargs) -> None: ...
    @staticmethod
    def append(*args, **kwargs) -> None: ...
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def count(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def insert(*args, **kwargs) -> None: ...
    @staticmethod
    def remove(*args, **kwargs) -> None: ...
    @staticmethod
    def replace(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    pass
class ListProxy_SdfSubLayerTypePolicy(Boost.Python.instance):
    @staticmethod
    def ApplyEditsToList(*args, **kwargs) -> None: ...
    @staticmethod
    def ApplyList(*args, **kwargs) -> None: ...
    @staticmethod
    def append(*args, **kwargs) -> None: ...
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def count(*args, **kwargs) -> None: ...
    @staticmethod
    def index(*args, **kwargs) -> None: ...
    @staticmethod
    def insert(*args, **kwargs) -> None: ...
    @staticmethod
    def remove(*args, **kwargs) -> None: ...
    @staticmethod
    def replace(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    pass
class MapEditProxy_VtDictionary(Boost.Python.instance):
    class MapEditProxy_VtDictionary_Iterator(Boost.Python.instance):
        pass
    class MapEditProxy_VtDictionary_KeyIterator(Boost.Python.instance):
        pass
    class MapEditProxy_VtDictionary_ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def pop(*args, **kwargs) -> None: ...
    @staticmethod
    def popitem(*args, **kwargs) -> None: ...
    @staticmethod
    def setdefault(*args, **kwargs) -> None: ...
    @staticmethod
    def update(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 32
    pass
class MapEditProxy_map_SdfPath_SdfPath_less_SdfPath__allocator_pair_SdfPath_const__SdfPath_____(Boost.Python.instance):
    class MapEditProxy_map_SdfPath_SdfPath_less_SdfPath__allocator_pair_SdfPath_const__SdfPath______Iterator(Boost.Python.instance):
        pass
    class MapEditProxy_map_SdfPath_SdfPath_less_SdfPath__allocator_pair_SdfPath_const__SdfPath______KeyIterator(Boost.Python.instance):
        pass
    class MapEditProxy_map_SdfPath_SdfPath_less_SdfPath__allocator_pair_SdfPath_const__SdfPath______ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def pop(*args, **kwargs) -> None: ...
    @staticmethod
    def popitem(*args, **kwargs) -> None: ...
    @staticmethod
    def setdefault(*args, **kwargs) -> None: ...
    @staticmethod
    def update(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 32
    pass
class MapEditProxy_map_string_string_less_string__allocator_pair_stringconst__string_____(Boost.Python.instance):
    class MapEditProxy_map_string_string_less_string__allocator_pair_stringconst__string______Iterator(Boost.Python.instance):
        pass
    class MapEditProxy_map_string_string_less_string__allocator_pair_stringconst__string______KeyIterator(Boost.Python.instance):
        pass
    class MapEditProxy_map_string_string_less_string__allocator_pair_stringconst__string______ValueIterator(Boost.Python.instance):
        pass
    @staticmethod
    def clear(*args, **kwargs) -> None: ...
    @staticmethod
    def copy(*args, **kwargs) -> None: ...
    @staticmethod
    def get(*args, **kwargs) -> None: ...
    @staticmethod
    def items(*args, **kwargs) -> None: ...
    @staticmethod
    def keys(*args, **kwargs) -> None: ...
    @staticmethod
    def pop(*args, **kwargs) -> None: ...
    @staticmethod
    def popitem(*args, **kwargs) -> None: ...
    @staticmethod
    def setdefault(*args, **kwargs) -> None: ...
    @staticmethod
    def update(*args, **kwargs) -> None: ...
    @staticmethod
    def values(*args, **kwargs) -> None: ...
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 32
    pass
class NamespaceEdit(Boost.Python.instance):
    """
    A single namespace edit. It supports renaming, reparenting,
    reparenting with a rename, reordering, and removal.
    """
    @staticmethod
    def Remove(*args, **kwargs) -> None: 
        """
        **classmethod** Remove(currentPath) -> This


        Returns a namespace edit that removes the object at ``currentPath`` .


        Parameters
        ----------
        currentPath : Path
        """
    @staticmethod
    def Rename(*args, **kwargs) -> None: 
        """
        **classmethod** Rename(currentPath, name) -> This


        Returns a namespace edit that renames the prim or property at
        ``currentPath`` to ``name`` .


        Parameters
        ----------
        currentPath : Path

        name : str
        """
    @staticmethod
    def Reorder(*args, **kwargs) -> None: 
        """
        **classmethod** Reorder(currentPath, index) -> This


        Returns a namespace edit to reorder the prim or property at
        ``currentPath`` to index ``index`` .


        Parameters
        ----------
        currentPath : Path

        index : Index
        """
    @staticmethod
    def Reparent(*args, **kwargs) -> None: 
        """
        **classmethod** Reparent(currentPath, newParentPath, index) -> This


        Returns a namespace edit to reparent the prim or property at
        ``currentPath`` to be under ``newParentPath`` at index ``index`` .


        Parameters
        ----------
        currentPath : Path

        newParentPath : Path

        index : Index
        """
    @staticmethod
    def ReparentAndRename(*args, **kwargs) -> None: 
        """
        **classmethod** ReparentAndRename(currentPath, newParentPath, name, index) -> This


        Returns a namespace edit to reparent the prim or property at
        ``currentPath`` to be under ``newParentPath`` at index ``index`` with
        the name ``name`` .


        Parameters
        ----------
        currentPath : Path

        newParentPath : Path

        name : str

        index : Index
        """
    @property
    def currentPath(self) -> None:
        """
        :type: None
        """
    @property
    def index(self) -> None:
        """
        :type: None
        """
    @property
    def newPath(self) -> None:
        """
        :type: None
        """
    atEnd = -1
    same = -2
    pass
class NamespaceEditDetail(Boost.Python.instance):
    """
    Detailed information about a namespace edit.
    """
    class Result(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
        """
        Validity of an edit.
        """
        @staticmethod
        def GetValueFromName(*args, **kwargs) -> None: ...
        _baseName = 'NamespaceEditDetail'
        allValues: tuple # value = (Sdf.NamespaceEditDetail.Error, Sdf.NamespaceEditDetail.Unbatched, Sdf.NamespaceEditDetail.Okay)
        pass
    @property
    def edit(self) -> None:
        """
        :type: None
        """
    @property
    def reason(self) -> None:
        """
        :type: None
        """
    @property
    def result(self) -> None:
        """
        :type: None
        """
    Error: pxr.Sdf.Result # value = Sdf.NamespaceEditDetail.Error
    Okay: pxr.Sdf.Result # value = Sdf.NamespaceEditDetail.Okay
    Unbatched: pxr.Sdf.Result # value = Sdf.NamespaceEditDetail.Unbatched
    pass
class Notice(Boost.Python.instance):
    """
    Wrapper class for Sdf notices.
    """
    class Base(pxr.Tf.Notice, Boost.Python.instance):
        pass
    class LayerDidReloadContent(LayerDidReplaceContent, Base, pxr.Tf.Notice, Boost.Python.instance):
        pass
    class LayerDidReplaceContent(Base, pxr.Tf.Notice, Boost.Python.instance):
        pass
    class LayerDirtinessChanged(Base, pxr.Tf.Notice, Boost.Python.instance):
        pass
    class LayerIdentifierDidChange(Base, pxr.Tf.Notice, Boost.Python.instance):
        @property
        def newIdentifier(self) -> None:
            """
            :type: None
            """
        @property
        def oldIdentifier(self) -> None:
            """
            :type: None
            """
        pass
    class LayerInfoDidChange(Base, pxr.Tf.Notice, Boost.Python.instance):
        @staticmethod
        def key(*args, **kwargs) -> None: ...
        pass
    class LayerMutenessChanged(Base, pxr.Tf.Notice, Boost.Python.instance):
        @property
        def layerPath(self) -> None:
            """
            :type: None
            """
        @property
        def wasMuted(self) -> None:
            """
            :type: None
            """
        pass
    class LayersDidChange(Base, pxr.Tf.Notice, Boost.Python.instance):
        @staticmethod
        def GetLayers(*args, **kwargs) -> None: ...
        @staticmethod
        def GetSerialNumber(*args, **kwargs) -> None: ...
        pass
    class LayersDidChangeSentPerLayer(Base, pxr.Tf.Notice, Boost.Python.instance):
        @staticmethod
        def GetLayers(*args, **kwargs) -> None: ...
        @staticmethod
        def GetSerialNumber(*args, **kwargs) -> None: ...
        pass
    pass
class Path(Boost.Python.instance):
    """
    A path value used to locate objects in layers or scenegraphs.

    Overview
    ========

    SdfPath is used in several ways:

       - As a storage key for addressing and accessing values held in a
         SdfLayer

       - As a namespace identity for scenegraph objects

       - As a way to refer to other scenegraph objects through relative
         paths
         The paths represented by an SdfPath class may be either relative or
         absolute. Relative paths are relative to the prim object that contains
         them (that is, if an SdfRelationshipSpec target is relative, it is
         relative to the SdfPrimSpec object that owns the SdfRelationshipSpec
         object).

    SdfPath objects can be readily created from and converted back to
    strings, but as SdfPath objects, they have behaviors that make it easy
    and efficient to work with them. The SdfPath class provides a full
    range of methods for manipulating scene paths by appending a namespace
    child, appending a relationship target, getting the parent path, and
    so on. Since the SdfPath class uses a node-based representation
    internally, you should use the editing functions rather than
    converting to and from strings if possible.

    Path Syntax
    ===========

    Like a filesystem path, an SdfPath is conceptually just a sequence of
    path components. Unlike a filesystem path, each component has a type,
    and the type is indicated by the syntax.

    Two separators are used between parts of a path. A slash ("/")
    following an identifier is used to introduce a namespace child. A
    period (".") following an identifier is used to introduce a property.
    A property may also have several non-sequential colons (':') in its
    name to provide a rudimentary namespace within properties but may not
    end or begin with a colon.

    A leading slash in the string representation of an SdfPath object
    indicates an absolute path. Two adjacent periods indicate the parent
    namespace.

    Brackets ("["and"]") are used to indicate relationship target paths
    for relational attributes.

    The first part in a path is assumed to be a namespace child unless it
    is preceded by a period. That means:

       - ``/Foo`` is an absolute path specifying the root prim Foo.

       - ``/Foo/Bar`` is an absolute path specifying namespace child Bar
         of root prim Foo.

       - ``/Foo/Bar.baz`` is an absolute path specifying property ``baz``
         of namespace child Bar of root prim Foo.

       - ``Foo`` is a relative path specifying namespace child Foo of the
         current prim.

       - ``Foo/Bar`` is a relative path specifying namespace child Bar of
         namespace child Foo of the current prim.

       - ``Foo/Bar.baz`` is a relative path specifying property ``baz`` of
         namespace child Bar of namespace child Foo of the current prim.

       - ``.foo`` is a relative path specifying the property ``foo`` of
         the current prim.

       - ``/Foo.bar[/Foo.baz].attrib`` is a relational attribute path. The
         relationship ``/Foo.bar`` has a target ``/Foo.baz`` . There is a
         relational attribute ``attrib`` on that relationship->target pair.

    A Note on Thread-Safety
    =======================

    SdfPath is strongly thread-safe, in the sense that zero additional
    synchronization is required between threads creating or using SdfPath
    values. Just like TfToken, SdfPath values are immutable. Internally,
    SdfPath uses a global prefix tree to efficiently share representations
    of paths, and provide fast equality/hashing operations, but
    modifications to this table are internally synchronized. Consequently,
    as with TfToken, for best performance it is important to minimize the
    number of values created (since it requires synchronized access to
    this table) or copied (since it requires atomic ref-counting
    operations).
    """
    class AncestorsRange(Boost.Python.instance):
        class _iterator(Boost.Python.instance):
            pass
        @staticmethod
        def GetPath(*args, **kwargs) -> None: ...
        __instance_size__ = 24
        pass
    class _IsValidPathStringResult(Boost.Python.instance):
        @property
        def errorMessage(self) -> None:
            """
            :type: None
            """
        __instance_size__ = 56
        pass
    @staticmethod
    def AppendChild(childName) -> Path: 
        """
        AppendChild(childName) -> Path


        Creates a path by appending an element for ``childName`` to this path.


        This path must be a prim path, the AbsoluteRootPath or the
        ReflexiveRelativePath.


        Parameters
        ----------
        childName : str
        """
    @staticmethod
    def AppendElementString(element) -> Path: 
        """
        AppendElementString(element) -> Path


        Creates a path by extracting and appending an element from the given
        ascii element encoding.


        Attempting to append a root or empty path (or malformed path) or
        attempting to append *to* the EmptyPath will raise an error and return
        the EmptyPath.

        May also fail and return EmptyPath if this path's type cannot possess
        a child of the type encoded in ``element`` .


        Parameters
        ----------
        element : str
        """
    @staticmethod
    def AppendExpression() -> Path: 
        """
        AppendExpression() -> Path


        Creates a path by appending an expression element.


        This path must be a prim property or relational attribute path.
        """
    @staticmethod
    def AppendMapper(targetPath) -> Path: 
        """
        AppendMapper(targetPath) -> Path


        Creates a path by appending a mapper element for ``targetPath`` .


        This path must be a prim property or relational attribute path.


        Parameters
        ----------
        targetPath : Path
        """
    @staticmethod
    def AppendMapperArg(argName) -> Path: 
        """
        AppendMapperArg(argName) -> Path


        Creates a path by appending an element for ``argName`` .


        This path must be a mapper path.


        Parameters
        ----------
        argName : str
        """
    @staticmethod
    def AppendPath(newSuffix) -> Path: 
        """
        AppendPath(newSuffix) -> Path


        Creates a path by appending a given relative path to this path.


        If the newSuffix is a prim path, then this path must be a prim path or
        a root path.

        If the newSuffix is a prim property path, then this path must be a
        prim path or the ReflexiveRelativePath.


        Parameters
        ----------
        newSuffix : Path
        """
    @staticmethod
    def AppendProperty(propName) -> Path: 
        """
        AppendProperty(propName) -> Path


        Creates a path by appending an element for ``propName`` to this path.


        This path must be a prim path or the ReflexiveRelativePath.


        Parameters
        ----------
        propName : str
        """
    @staticmethod
    def AppendRelationalAttribute(attrName) -> Path: 
        """
        AppendRelationalAttribute(attrName) -> Path


        Creates a path by appending an element for ``attrName`` to this path.


        This path must be a target path.


        Parameters
        ----------
        attrName : str
        """
    @staticmethod
    def AppendTarget(targetPath) -> Path: 
        """
        AppendTarget(targetPath) -> Path


        Creates a path by appending an element for ``targetPath`` .


        This path must be a prim property or relational attribute path.


        Parameters
        ----------
        targetPath : Path
        """
    @staticmethod
    def AppendVariantSelection(variantSet, variant) -> Path: 
        """
        AppendVariantSelection(variantSet, variant) -> Path


        Creates a path by appending an element for ``variantSet`` and
        ``variant`` to this path.


        This path must be a prim path.


        Parameters
        ----------
        variantSet : str

        variant : str
        """
    @staticmethod
    def ContainsPrimVariantSelection() -> bool: 
        """
        ContainsPrimVariantSelection() -> bool


        Returns whether the path or any of its parent paths identifies a
        variant selection for a prim.
        """
    @staticmethod
    def ContainsPropertyElements() -> bool: 
        """
        ContainsPropertyElements() -> bool


        Return true if this path contains any property elements, false
        otherwise.


        A false return indicates a prim-like path, specifically a root path, a
        prim path, or a prim variant selection path. A true return indicates a
        property-like path: a prim property path, a target path, a relational
        attribute path, etc.
        """
    @staticmethod
    def ContainsTargetPath() -> bool: 
        """
        ContainsTargetPath() -> bool


        Return true if this path is or has a prefix that's a target path or a
        mapper path.
        """
    @staticmethod
    def FindLongestPrefix(*args, **kwargs) -> None: ...
    @staticmethod
    def FindLongestStrictPrefix(*args, **kwargs) -> None: ...
    @staticmethod
    def FindPrefixedRange(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAbsoluteRootOrPrimPath() -> Path: 
        """
        GetAbsoluteRootOrPrimPath() -> Path


        Creates a path by stripping all properties and relational attributes
        from this path, leaving the path to the containing prim.


        If the path is already a prim or absolute root path, the same path is
        returned.
        """
    @staticmethod
    def GetAllTargetPathsRecursively(result) -> None: 
        """
        GetAllTargetPathsRecursively(result) -> None


        Returns all the relationship target or connection target paths
        contained in this path, and recursively all the target paths contained
        in those target paths in reverse depth-first order.


        For example, given the
        path:'/A/B.a[/C/D.a[/E/F.a]].a[/A/B.a[/C/D.a]]'this method
        produces:'/A/B.a[/C/D.a]','/C/D.a','/C/D.a[/E/F.a]','/E/F.a'


        Parameters
        ----------
        result : list[SdfPath]
        """
    @staticmethod
    def GetAncestorsRange() -> SdfPathAncestorsRange: 
        """
        GetAncestorsRange() -> SdfPathAncestorsRange


        Return a range for iterating over the ancestors of this path.


        The range provides iteration over the prefixes of a path, ordered from
        longest to shortest (the opposite of the order of the prefixes
        returned by GetPrefixes).
        """
    @staticmethod
    def GetCommonPrefix(path) -> Path: 
        """
        GetCommonPrefix(path) -> Path


        Returns a path with maximal length that is a prefix path of both this
        path and ``path`` .


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetConciseRelativePaths(*args, **kwargs) -> None: 
        """
        **classmethod** GetConciseRelativePaths(paths) -> list[SdfPath]


        Given some vector of paths, get a vector of concise unambiguous
        relative paths.


        GetConciseRelativePaths requires a vector of absolute paths. It finds
        a set of relative paths such that each relative path is unique.


        Parameters
        ----------
        paths : list[SdfPath]
        """
    @staticmethod
    def GetParentPath() -> Path: 
        """
        GetParentPath() -> Path


        Return the path that identifies this path's namespace parent.


        For a prim path (like'/foo/bar'), return the prim's parent's path
        ('/foo'). For a prim property path (like'/foo/bar.property'), return
        the prim's path ('/foo/bar'). For a target path
        (like'/foo/bar.property[/target]') return the property path
        ('/foo/bar.property'). For a mapper path
        (like'/foo/bar.property.mapper[/target]') return the property path
        ('/foo/bar.property). For a relational attribute path
        (like'/foo/bar.property[/target].relAttr') return the relationship
        target's path ('/foo/bar.property[/target]'). For a prim variant
        selection path (like'/foo/bar{var=sel}') return the prim path
        ('/foo/bar'). For a root prim path (like'/rootPrim'), return
        AbsoluteRootPath() ('/'). For a single element relative prim path
        (like'relativePrim'), return ReflexiveRelativePath() ('.'). For
        ReflexiveRelativePath() , return the relative parent path ('\.\.').

        Note that the parent path of a relative parent path ('\.\.') is a
        relative grandparent path ('\.\./\.\.'). Use caution writing loops
        that walk to parent paths since relative paths have infinitely many
        ancestors. To more safely traverse ancestor paths, consider iterating
        over an SdfPathAncestorsRange instead, as returend by
        GetAncestorsRange() .
        """
    @staticmethod
    def GetPrefixes(*args, **kwargs) -> None: 
        """
        Returns the prefix paths of this path.
        """
    @staticmethod
    def GetPrimOrPrimVariantSelectionPath() -> Path: 
        """
        GetPrimOrPrimVariantSelectionPath() -> Path


        Creates a path by stripping all relational attributes, targets, and
        properties, leaving the nearest path for which
        *IsPrimOrPrimVariantSelectionPath()* returns true.


        See *GetPrimPath* also.

        If the path is already a prim or a prim variant selection path, the
        same path is returned.
        """
    @staticmethod
    def GetPrimPath() -> Path: 
        """
        GetPrimPath() -> Path


        Creates a path by stripping all relational attributes, targets,
        properties, and variant selections from the leafmost prim path,
        leaving the nearest path for which *IsPrimPath()* returns true.


        See *GetPrimOrPrimVariantSelectionPath* also.

        If the path is already a prim path, the same path is returned.
        """
    @staticmethod
    def GetVariantSelection() -> tuple[str, str]: 
        """
        GetVariantSelection() -> tuple[str, str]


        Returns the variant selection for this path, if this is a variant
        selection path.


        Returns a pair of empty strings if this path is not a variant
        selection path.
        """
    @staticmethod
    def HasPrefix(prefix) -> bool: 
        """
        HasPrefix(prefix) -> bool


        Return true if both this path and *prefix* are not the empty path and
        this path has *prefix* as a prefix.


        Return false otherwise.


        Parameters
        ----------
        prefix : Path
        """
    @staticmethod
    def IsAbsolutePath() -> bool: 
        """
        IsAbsolutePath() -> bool


        Returns whether the path is absolute.
        """
    @staticmethod
    def IsAbsoluteRootOrPrimPath() -> bool: 
        """
        IsAbsoluteRootOrPrimPath() -> bool


        Returns whether the path identifies a prim or the absolute root.
        """
    @staticmethod
    def IsAbsoluteRootPath() -> bool: 
        """
        IsAbsoluteRootPath() -> bool


        Return true if this path is the AbsoluteRootPath() .
        """
    @staticmethod
    def IsExpressionPath() -> bool: 
        """
        IsExpressionPath() -> bool


        Returns whether the path identifies a connection expression.
        """
    @staticmethod
    def IsMapperArgPath() -> bool: 
        """
        IsMapperArgPath() -> bool


        Returns whether the path identifies a connection mapper arg.
        """
    @staticmethod
    def IsMapperPath() -> bool: 
        """
        IsMapperPath() -> bool


        Returns whether the path identifies a connection mapper.
        """
    @staticmethod
    def IsNamespacedPropertyPath() -> bool: 
        """
        IsNamespacedPropertyPath() -> bool


        Returns whether the path identifies a namespaced property.


        A namespaced property has colon embedded in its name.
        """
    @staticmethod
    def IsPrimPath() -> bool: 
        """
        IsPrimPath() -> bool


        Returns whether the path identifies a prim.
        """
    @staticmethod
    def IsPrimPropertyPath() -> bool: 
        """
        IsPrimPropertyPath() -> bool


        Returns whether the path identifies a prim's property.


        A relational attribute is not a prim property.
        """
    @staticmethod
    def IsPrimVariantSelectionPath() -> bool: 
        """
        IsPrimVariantSelectionPath() -> bool


        Returns whether the path identifies a variant selection for a prim.
        """
    @staticmethod
    def IsPropertyPath() -> bool: 
        """
        IsPropertyPath() -> bool


        Returns whether the path identifies a property.


        A relational attribute is considered to be a property, so this method
        will return true for relational attributes as well as properties of
        prims.
        """
    @staticmethod
    def IsRelationalAttributePath() -> bool: 
        """
        IsRelationalAttributePath() -> bool


        Returns whether the path identifies a relational attribute.


        If this is true, IsPropertyPath() will also be true.
        """
    @staticmethod
    def IsRootPrimPath() -> bool: 
        """
        IsRootPrimPath() -> bool


        Returns whether the path identifies a root prim.


        the path must be absolute and have a single element (for example
        ``/foo`` ).
        """
    @staticmethod
    def IsTargetPath() -> bool: 
        """
        IsTargetPath() -> bool


        Returns whether the path identifies a relationship or connection
        target.
        """
    @staticmethod
    def IsValidIdentifier(*args, **kwargs) -> None: 
        """
        **classmethod** IsValidIdentifier(name) -> bool


        Returns whether ``name`` is a legal identifier for any path component.


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


        Returns whether ``name`` is a legal namespaced identifier.


        This returns ``true`` if IsValidIdentifier() does.


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


        Return true if ``pathString`` is a valid path string, meaning that
        passing the string to the *SdfPath* constructor will result in a
        valid, non-empty SdfPath.


        Otherwise, return false and if ``errMsg`` is not None, set the
        pointed-to string to the parse error.


        Parameters
        ----------
        pathString : str

        errMsg : str
        """
    @staticmethod
    @typing.overload
    def JoinIdentifier(names) -> str: 
        """
        **classmethod** JoinIdentifier(names) -> str


        Join ``names`` into a single identifier using the namespace delimiter.


        Any empty strings present in ``names`` are ignored when joining.


        Parameters
        ----------
        names : list[str]



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


        Join ``names`` into a single identifier using the namespace delimiter.


        Any empty strings present in ``names`` are ignored when joining.


        Parameters
        ----------
        names : list[TfToken]



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


        Join ``lhs`` and ``rhs`` into a single identifier using the namespace
        delimiter.


        Returns ``lhs`` if ``rhs`` is empty and vice verse. Returns an empty
        string if both ``lhs`` and ``rhs`` are empty.


        Parameters
        ----------
        lhs : str

        rhs : str



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


        Join ``lhs`` and ``rhs`` into a single identifier using the namespace
        delimiter.


        Returns ``lhs`` if ``rhs`` is empty and vice verse. Returns an empty
        string if both ``lhs`` and ``rhs`` are empty.


        Parameters
        ----------
        lhs : str

        rhs : str
        """
    @staticmethod
    @typing.overload
    def JoinIdentifier(lhs, rhs) -> str: ...
    @staticmethod
    def MakeAbsolutePath(anchor) -> Path: 
        """
        MakeAbsolutePath(anchor) -> Path


        Returns the absolute form of this path using ``anchor`` as the
        relative basis.


        ``anchor`` must be an absolute prim path.

        If this path is a relative path, resolve it using ``anchor`` as the
        relative basis.

        If this path is already an absolute path, just return a copy.


        Parameters
        ----------
        anchor : Path
        """
    @staticmethod
    def MakeRelativePath(anchor) -> Path: 
        """
        MakeRelativePath(anchor) -> Path


        Returns the relative form of this path using ``anchor`` as the
        relative basis.


        ``anchor`` must be an absolute prim path.

        If this path is an absolute path, return the corresponding relative
        path that is relative to the absolute path given by ``anchor`` .

        If this path is a relative path, return the optimal relative path to
        the absolute path given by ``anchor`` . (The optimal relative path
        from a given prim path is the relative path with the least leading
        dot-dots.


        Parameters
        ----------
        anchor : Path
        """
    @staticmethod
    def RemoveAncestorPaths(*args, **kwargs) -> None: 
        """
        **classmethod** RemoveAncestorPaths(paths) -> None


        Remove all elements of *paths* that prefix other elements in *paths*.


        As a side-effect, the result is left in sorted order.


        Parameters
        ----------
        paths : list[SdfPath]
        """
    @staticmethod
    def RemoveCommonSuffix(otherPath, stopAtRootPrim) -> tuple[Path, Path]: 
        """
        RemoveCommonSuffix(otherPath, stopAtRootPrim) -> tuple[Path, Path]


        Find and remove the longest common suffix from two paths.


        Returns this path and ``otherPath`` with the longest common suffix
        removed (first and second, respectively). If the two paths have no
        common suffix then the paths are returned as-is. If the paths are
        equal then this returns empty paths for relative paths and absolute
        roots for absolute paths. The paths need not be the same length.

        If ``stopAtRootPrim`` is ``true`` then neither returned path will be
        the root path. That, in turn, means that some common suffixes will not
        be removed. For example, if ``stopAtRootPrim`` is ``true`` then the
        paths /A/B and /B will be returned as is. Were it ``false`` then the
        result would be /A and /. Similarly paths /A/B/C and /B/C would return
        /A/B and /B if ``stopAtRootPrim`` is ``true`` but /A and / if it's
        ``false`` .


        Parameters
        ----------
        otherPath : Path

        stopAtRootPrim : bool
        """
    @staticmethod
    def RemoveDescendentPaths(*args, **kwargs) -> None: 
        """
        **classmethod** RemoveDescendentPaths(paths) -> None


        Remove all elements of *paths* that are prefixed by other elements in
        *paths*.


        As a side-effect, the result is left in sorted order.


        Parameters
        ----------
        paths : list[SdfPath]
        """
    @staticmethod
    def ReplaceName(newName) -> Path: 
        """
        ReplaceName(newName) -> Path


        Return a copy of this path with its final component changed to
        *newName*.


        This path must be a prim or property path.

        This method is shorthand for path.GetParentPath().AppendChild(newName)
        for prim paths, path.GetParentPath().AppendProperty(newName) for prim
        property paths, and
        path.GetParentPath().AppendRelationalAttribute(newName) for relational
        attribute paths.

        Note that only the final path component is ever changed. If the name
        of the final path component appears elsewhere in the path, it will not
        be modified.

        Some examples:


        Parameters
        ----------
        newName : str
        """
    @staticmethod
    def ReplacePrefix(oldPrefix, newPrefix, fixTargetPaths) -> Path: 
        """
        ReplacePrefix(oldPrefix, newPrefix, fixTargetPaths) -> Path


        Returns a path with all occurrences of the prefix path ``oldPrefix``
        replaced with the prefix path ``newPrefix`` .


        If fixTargetPaths is true, any embedded target paths will also have
        their paths replaced. This is the default.

        If this is not a target, relational attribute or mapper path this will
        do zero or one path prefix replacements, if not the number of
        replacements can be greater than one.


        Parameters
        ----------
        oldPrefix : Path

        newPrefix : Path

        fixTargetPaths : bool
        """
    @staticmethod
    def ReplaceTargetPath(newTargetPath) -> Path: 
        """
        ReplaceTargetPath(newTargetPath) -> Path


        Replaces the relational attribute's target path.


        The path must be a relational attribute path.


        Parameters
        ----------
        newTargetPath : Path
        """
    @staticmethod
    def StripAllVariantSelections() -> Path: 
        """
        StripAllVariantSelections() -> Path


        Create a path by stripping all variant selections from all components
        of this path, leaving a path with no embedded variant selections.
        """
    @staticmethod
    def StripNamespace(name) -> str: 
        """
        **classmethod** StripNamespace(name) -> str


        Returns ``name`` stripped of any namespaces.


        This does not check the validity of the name; it just attempts to
        remove anything that looks like a namespace.


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



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


        Returns ``name`` stripped of any namespaces.


        This does not check the validity of the name; it just attempts to
        remove anything that looks like a namespace.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def StripPrefixNamespace(*args, **kwargs) -> None: 
        """
        **classmethod** StripPrefixNamespace(name, matchNamespace) -> tuple[str, bool]


        Returns ( ``name`` , ``true`` ) where ``name`` is stripped of the
        prefix specified by ``matchNamespace`` if ``name`` indeed starts with
        ``matchNamespace`` .


        Returns ( ``name`` , ``false`` ) otherwise, with ``name`` unmodified.

        This function deals with both the case where ``matchNamespace``
        contains the trailing namespace delimiter':'or not.


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

        matchNamespace : str
        """
    @staticmethod
    def TokenizeIdentifier(*args, **kwargs) -> None: 
        """
        **classmethod** TokenizeIdentifier(name) -> list[str]


        Tokenizes ``name`` by the namespace delimiter.


        Returns the empty vector if ``name`` is not a valid namespaced
        identifier.


        Parameters
        ----------
        name : str
        """
    @property
    def elementString(self) -> None:
        """
        The string representation of the terminal component of this path.
        This path can be reconstructed via 
        thisPath.GetParentPath().AppendElementString(thisPath.element).
        None of absoluteRootPath, reflexiveRelativePath, nor emptyPath
        possess the above quality; their .elementString is the empty string.

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


        Returns true if this is the empty path ( SdfPath::EmptyPath() ).

        :type: None
        """
    @property
    def name(self) -> None:
        """
        The name of the prim, property or relational
        attribute identified by the path.

        '' for EmptyPath.  '.' for ReflexiveRelativePath.
        '..' for a path ending in ParentPathElement.

        :type: None
        """
    @property
    def pathElementCount(self) -> None:
        """
        The number of path elements in this path.

        :type: None
        """
    @property
    def pathString(self) -> None:
        """
        The string representation of this path.

        :type: None
        """
    @property
    def targetPath(self) -> None:
        """
        The relational attribute target path for this path.

        EmptyPath if this is not a relational attribute path.

        :type: None
        """
    __instance_size__ = 24
    absoluteIndicator = '/'
    absoluteRootPath: pxr.Sdf.Path # value = Sdf.Path('/')
    childDelimiter = '/'
    emptyPath: pxr.Sdf.Path # value = Sdf.Path.emptyPath
    expressionIndicator = 'expression'
    mapperArgDelimiter = '.'
    mapperIndicator = 'mapper'
    namespaceDelimiter = ':'
    parentPathElement = '..'
    propertyDelimiter = '.'
    reflexiveRelativePath: pxr.Sdf.Path # value = Sdf.Path('.')
    relationshipTargetEnd = ']'
    relationshipTargetStart = '['
    pass
class PathArray(Boost.Python.instance):
    """
    An array of type SdfPath.
    """
    _isVtArray = True
    pass
class PathListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class Payload(Boost.Python.instance):
    """
    Represents a payload and all its meta data.

    A payload represents a prim reference to an external layer. A payload
    is similar to a prim reference (see SdfReference) with the major
    difference that payloads are explicitly loaded by the user.

    Unloaded payloads represent a boundary that lazy composition and
    system behaviors will not traverse across, providing a user-visible
    way to manage the working set of the scene.
    """
    @property
    def assetPath(self) -> None:
        """
        type : None


        Sets a new asset path for the layer the payload uses.


        See SdfAssetPath for what characters are valid in ``assetPath`` . If
        ``assetPath`` contains invalid characters, issue an error and set this
        payload's asset path to the empty asset path.

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

        type : str


        Returns the asset path of the layer that the payload uses.

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


        Sets a new layer offset.

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

        type : LayerOffset


        Returns the layer offset associated with the payload.

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


        Sets a new prim path for the prim that the payload uses.

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

        type : Path


        Returns the scene path of the prim for the payload.

        :type: None
        """
    __instance_size__ = 72
    pass
class PayloadListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class Permission(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.PermissionPublic, Sdf.PermissionPrivate)
    pass
class PrimSpec(Spec, Boost.Python.instance):
    """
    Represents a prim description in an SdfLayer object.

    Every SdfPrimSpec object is defined in a layer. It is identified by
    its path (SdfPath class) in the namespace hierarchy of its layer.
    SdfPrimSpecs can be created using the New() method as children of
    either the containing SdfLayer itself (for"root level"prims), or as
    children of other SdfPrimSpec objects to extend a hierarchy. The
    helper function SdfCreatePrimInLayer() can be used to quickly create a
    hierarchy of primSpecs.

    SdfPrimSpec objects have properties of two general types: attributes
    (containing values) and relationships (different types of connections
    to other prims and attributes). Attributes are represented by the
    SdfAttributeSpec class and relationships by the SdfRelationshipSpec
    class. Each prim has its own namespace of properties. Properties are
    stored and accessed by their name.

    SdfPrimSpec objects have a typeName, permission restriction, and they
    reference and inherit prim paths. Permission restrictions control
    which other layers may refer to, or express opinions about a prim. See
    the SdfPermission class for more information.

       - Insert doc about references and inherits here.

       - Should have validate\.\.\. methods for name, children,
         properties
    """
    @staticmethod
    def ApplyNameChildrenOrder(vec) -> None: 
        """
        ApplyNameChildrenOrder(vec) -> None


        Reorders the given list of child names according to the reorder
        nameChildren statement for this prim.


        This routine employs the standard list editing operation for ordered
        items in a ListEditor.


        Parameters
        ----------
        vec : list[str]
        """
    @staticmethod
    def ApplyPropertyOrder(vec) -> None: 
        """
        ApplyPropertyOrder(vec) -> None


        Reorders the given list of property names according to the reorder
        properties statement for this prim.


        This routine employs the standard list editing operation for ordered
        items in a ListEditor.


        Parameters
        ----------
        vec : list[str]
        """
    @staticmethod
    def BlockVariantSelection(variantSetName) -> None: 
        """
        BlockVariantSelection(variantSetName) -> None


        Blocks the variant selected for the given variant set by setting the
        variant selection to empty.


        Parameters
        ----------
        variantSetName : str
        """
    @staticmethod
    def CanSetName(newName, whyNot) -> bool: 
        """
        CanSetName(newName, whyNot) -> bool


        Returns true if setting the prim spec's name to ``newName`` will
        succeed.


        Returns false if it won't, and sets ``whyNot`` with a string
        describing why not.


        Parameters
        ----------
        newName : str

        whyNot : str
        """
    @staticmethod
    def ClearActive() -> None: 
        """
        ClearActive() -> None


        Removes the active opinion in this prim spec if there is one.
        """
    @staticmethod
    def ClearInstanceable() -> None: 
        """
        ClearInstanceable() -> None


        Clears the value for the prim's instanceable flag.
        """
    @staticmethod
    def ClearKind() -> None: 
        """
        ClearKind() -> None


        Remove the kind opinion from this prim spec if there is one.
        """
    @staticmethod
    def ClearPayloadList(*args, **kwargs) -> None: 
        """
        Clears the payloads for this prim.
        """
    @staticmethod
    def ClearReferenceList(*args, **kwargs) -> None: 
        """
        Clears the references for this prim.
        """
    @staticmethod
    def GetAttributeAtPath(path) -> AttributeSpec: 
        """
        GetAttributeAtPath(path) -> AttributeSpec


        Returns an attribute given its ``path`` .


        Returns invalid handle if there is no attribute at ``path`` . This is
        simply a more specifically typed version of GetObjectAtPath.


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetObjectAtPath(path) -> object: 
        """
        path: Path

        Returns a prim or property given its namespace path.

        If path is relative then it will be interpreted as relative to this prim.  If it is absolute then it will be interpreted as absolute in this prim's layer. The return type can be either PrimSpecPtr or PropertySpecPtr.
        """
    @staticmethod
    def GetPrimAtPath(path) -> PrimSpec: 
        """
        GetPrimAtPath(path) -> PrimSpec


        Returns a prim given its ``path`` .


        Returns invalid handle if there is no prim at ``path`` . This is
        simply a more specifically typed version of GetObjectAtPath.


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetPropertyAtPath(path) -> PropertySpec: 
        """
        GetPropertyAtPath(path) -> PropertySpec


        Returns a property given its ``path`` .


        Returns invalid handle if there is no property at ``path`` . This is
        simply a more specifically typed version of GetObjectAtPath.


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetRelationshipAtPath(path) -> RelationshipSpec: 
        """
        GetRelationshipAtPath(path) -> RelationshipSpec


        Returns a relationship given its ``path`` .


        Returns invalid handle if there is no relationship at ``path`` . This
        is simply a more specifically typed version of GetObjectAtPath.


        Parameters
        ----------
        path : Path
        """
    @staticmethod
    def GetVariantNames(name) -> list[str]: 
        """
        GetVariantNames(name) -> list[str]


        Returns list of variant names for the given variant set.


        Parameters
        ----------
        name : str
        """
    @staticmethod
    def HasActive() -> bool: 
        """
        HasActive() -> bool


        Returns true if this prim spec has an opinion about active.
        """
    @staticmethod
    def HasInstanceable() -> bool: 
        """
        HasInstanceable() -> bool


        Returns true if this prim spec has a value authored for its
        instanceable flag, false otherwise.
        """
    @staticmethod
    def HasKind() -> bool: 
        """
        HasKind() -> bool


        Returns true if this prim spec has an opinion about kind.
        """
    @staticmethod
    def RemoveProperty(property) -> None: 
        """
        RemoveProperty(property) -> None


        Removes the property.


        Parameters
        ----------
        property : PropertySpec
        """
    @property
    def active(self) -> None:
        """
        Whether this prim spec is active.
        The default value is true.

        :type: None
        """
    @property
    def assetInfo(self) -> None:
        """
        Returns the asset info dictionary for this prim.

        The default value is an empty dictionary.

        The asset info dictionary is used to annotate prims representing the root-prims of assets (generally organized as models) with various data related to asset management. For example, asset name, root layer identifier, asset version etc.

        :type: None
        """
    @property
    def attributes(self) -> None:
        """
        The attributes of this prim, as an ordered dictionary.

        :type: None
        """
    @property
    def comment(self) -> None:
        """
        The prim's comment string.

        :type: None
        """
    @property
    def customData(self) -> None:
        """
        The custom data for this prim.

        The default value for custom data is an empty dictionary.

        Custom data is for use by plugins or other non-tools supplied 
        extensions that need to be able to store data attached to arbitrary
        scene objects.  Note that if the only objects you want to store data
        on are prims, using custom attributes is probably a better choice.
        But if you need to possibly store this data on attributes or 
        relationships or as annotations on reference arcs, then custom data
        is an appropriate choice.

        :type: None
        """
    @property
    def documentation(self) -> None:
        """
        The prim's documentation string.

        :type: None
        """
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    @property
    def hasPayloads(self) -> None:
        """
        Returns true if this prim has payloads set.

        :type: None
        """
    @property
    def hasReferences(self) -> None:
        """
        Returns true if this prim has references set.

        :type: None
        """
    @property
    def hidden(self) -> None:
        """
        Whether this prim spec will be hidden in browsers.
        The default value is false.

        :type: None
        """
    @property
    def inheritPathList(self) -> None:
        """
        A PathListEditor for the prim's inherit paths.

        The list of the inherit paths for this prim may be modified with this PathListEditor.

        A PathListEditor may express a list either as an explicit value or as a set of list editing operations.  See PathListEditor for more information.

        :type: None
        """
    @property
    def instanceable(self) -> None:
        """
        Whether this prim spec is flagged as instanceable.
        The default value is false.

        :type: None
        """
    @property
    def kind(self) -> None:
        """
        What kind of model this prim spec represents, if any.
        The default is an empty string

        :type: None
        """
    @property
    def name(self) -> None:
        """
        The prim's name.

        :type: None
        """
    @property
    def nameChildren(self) -> None:
        """
        The prim name children of this prim, as an ordered dictionary.

        Note that although this property is described as being read-only, you can modify the contents to add, remove, or reorder children.

        :type: None
        """
    @property
    def nameChildrenOrder(self) -> None:
        """
        Get/set the list of child names for this prim's 'reorder nameChildren' statement.

        :type: None
        """
    @property
    def nameParent(self) -> None:
        """
        The name parent of this prim.

        :type: None
        """
    @property
    def nameRoot(self) -> None:
        """
        The name pseudo-root of this prim.

        :type: None
        """
    @property
    def payloadList(self) -> None:
        """
        A PayloadListEditor for the prim's payloads.

        The list of the payloads for this prim may be modified with this PayloadListEditor.

        A PayloadListEditor may express a list either as an explicit value or as a set of list editing operations.  See PayloadListEditor for more information.

        :type: None
        """
    @property
    def permission(self) -> None:
        """
        The prim's permission restriction.
        The default value is SdfPermissionPublic.

        :type: None
        """
    @property
    def prefix(self) -> None:
        """
        The prim's prefix.

        :type: None
        """
    @property
    def prefixSubstitutions(self) -> None:
        """
        Dictionary of prefix substitutions.

        :type: None
        """
    @property
    def properties(self) -> None:
        """
        The properties of this prim, as an ordered dictionary.

        Note that although this property is described as being read-only, you can modify the contents to add, remove, or reorder properties.

        :type: None
        """
    @property
    def propertyOrder(self) -> None:
        """
        Get/set the list of property names for this prim's 'reorder properties' statement.

        :type: None
        """
    @property
    def realNameParent(self) -> None:
        """
        The name parent of this prim.

        :type: None
        """
    @property
    def referenceList(self) -> None:
        """
        A ReferenceListEditor for the prim's references.

        The list of the references for this prim may be modified with this ReferenceListEditor.

        A ReferenceListEditor may express a list either as an explicit value or as a set of list editing operations.  See ReferenceListEditor for more information.

        :type: None
        """
    @property
    def relationships(self) -> None:
        """
        The relationships of this prim, as an ordered dictionary.

        :type: None
        """
    @property
    def relocates(self) -> None:
        """
        An editing proxy for the prim's map of relocation paths.

        The map of source-to-target paths specifying namespace relocation may be set or cleared whole, or individual map entries may be added, removed, or edited.

        :type: None
        """
    @property
    def specializesList(self) -> None:
        """
        A PathListEditor for the prim's specializes.

        The list of the specializes for this prim may be modified with this PathListEditor.

        A PathListEditor may express a list either as an explicit value or as a set of list editing operations.  See PathListEditor for more information.

        :type: None
        """
    @property
    def specifier(self) -> None:
        """
        The prim's specifier (SpecifierDef or SpecifierOver).
        The default value is SpecifierOver.

        :type: None
        """
    @property
    def suffix(self) -> None:
        """
        The prim's suffix.

        :type: None
        """
    @property
    def suffixSubstitutions(self) -> None:
        """
        Dictionary of prefix substitutions.

        :type: None
        """
    @property
    def symmetricPeer(self) -> None:
        """
        The prims's symmetric peer.

        :type: None
        """
    @property
    def symmetryArguments(self) -> None:
        """
        Dictionary with prim symmetry arguments.

        Although this property is marked read-only, you can modify the contents to add, change, and clear symmetry arguments.

        :type: None
        """
    @property
    def symmetryFunction(self) -> None:
        """
        The prim's symmetry function.

        :type: None
        """
    @property
    def typeName(self) -> None:
        """
        The type of this prim.

        :type: None
        """
    @property
    def variantSelections(self) -> None:
        """
        Dictionary whose keys are variant set names and whose values are the variants chosen for each set.

        Although this property is marked read-only, you can modify the contents to add, change, and clear variants.

        :type: None
        """
    @property
    def variantSetNameList(self) -> None:
        """
        A StringListEditor for the names of the variant 
        sets for this prim.

        The list of the names of the variants sets of this prim may be
        modified with this StringListEditor.

        A StringListEditor may express a list either as an explicit value or as a set of list editing operations.  See StringListEditor for more information.

        Although this property is marked as read-only, the returned object is modifiable.

        :type: None
        """
    @property
    def variantSets(self) -> None:
        """
        The VariantSetSpecs for this prim indexed by name.

        Although this property is marked as read-only, you can 
        modify the contents to remove variant sets.  New variant sets 
        are created by creating them with the prim as the owner.

        Although this property is marked as read-only, the returned object
        is modifiable.

        :type: None
        """
    ActiveKey = 'active'
    AnyTypeToken = '__AnyType__'
    CommentKey = 'comment'
    CustomDataKey = 'customData'
    DocumentationKey = 'documentation'
    HiddenKey = 'hidden'
    InheritPathsKey = 'inheritPaths'
    KindKey = 'kind'
    PayloadKey = 'payload'
    PermissionKey = 'permission'
    PrefixKey = 'prefix'
    PrefixSubstitutionsKey = 'prefixSubstitutions'
    PrimOrderKey = 'primOrder'
    PropertyOrderKey = 'propertyOrder'
    ReferencesKey = 'references'
    RelocatesKey = 'relocates'
    SpecializesKey = 'specializes'
    SpecifierKey = 'specifier'
    SymmetricPeerKey = 'symmetricPeer'
    SymmetryArgumentsKey = 'symmetryArguments'
    SymmetryFunctionKey = 'symmetryFunction'
    TypeNameKey = 'typeName'
    VariantSelectionKey = 'variantSelection'
    VariantSetNamesKey = 'variantSetNames'
    pass
class PropertySpec(Spec, Boost.Python.instance):
    """
    Base class for SdfAttributeSpec and SdfRelationshipSpec.

    Scene Spec Attributes (SdfAttributeSpec) and Relationships
    (SdfRelationshipSpec) are the basic properties that make up Scene Spec
    Prims (SdfPrimSpec). They share many qualities and can sometimes be
    treated uniformly. The common qualities are provided by this base
    class.

    NOTE: Do not use Python reserved words and keywords as attribute
    names. This will cause attribute resolution to fail.
    """
    @staticmethod
    def ClearDefaultValue() -> None: 
        """
        ClearDefaultValue() -> None


        Clear the attribute's default value.
        """
    @staticmethod
    def HasDefaultValue() -> bool: 
        """
        HasDefaultValue() -> bool


        Returns true if a default value is set for this attribute.
        """
    @property
    def assetInfo(self) -> None:
        """
        Returns the asset info dictionary for this property.

        The default value is an empty dictionary.

        The asset info dictionary is used to annotate SdfAssetPath-valued attributes pointing to the root-prims of assets (generally organized as models) with various data related to asset management. For example, asset name, root layer identifier, asset version etc.

        Note: It is only valid to author assetInfo on attributes that are of type SdfAssetPath.

        :type: None
        """
    @property
    def comment(self) -> None:
        """
        A comment describing the property.

        :type: None
        """
    @property
    def custom(self) -> None:
        """
        Whether this property spec declares a custom attribute.

        :type: None
        """
    @property
    def customData(self) -> None:
        """
        The property's custom data.

        The default value for custom data is an empty dictionary.

        Custom data is for use by plugins or other non-tools supplied 
        extensions that need to be able to store data attached to arbitrary
        scene objects.  Note that if the only objects you want to store data
        on are prims, using custom attributes is probably a better choice.
        But if you need to possibly store this data on attributes or 
        relationships or as annotations on reference arcs, then custom data
        is an appropriate choice.

        :type: None
        """
    @property
    def default(self) -> None:
        """
        The default value of this property.

        :type: None
        """
    @property
    def displayGroup(self) -> None:
        """
        DisplayGroup for the property.

        :type: None
        """
    @property
    def displayName(self) -> None:
        """
        DisplayName for the property.

        :type: None
        """
    @property
    def documentation(self) -> None:
        """
        Documentation for the property.

        :type: None
        """
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    @property
    def hasOnlyRequiredFields(self) -> None:
        """
        Indicates whether this spec has any significant data other 
        than just what is necessary for instantiation.

        This is a less strict version of isInert, returning True if 
        the spec contains as much as the type and name.

        :type: None
        """
    @property
    def hidden(self) -> None:
        """
        Whether this property will be hidden in browsers.

        :type: None
        """
    @property
    def name(self) -> None:
        """
        The name of the property.

        :type: None
        """
    @property
    def owner(self) -> None:
        """
        The owner of this property.  Either a relationship or a prim.

        :type: None
        """
    @property
    def permission(self) -> None:
        """
        The property's permission restriction.

        :type: None
        """
    @property
    def prefix(self) -> None:
        """
        Prefix for the property.

        :type: None
        """
    @property
    def symmetricPeer(self) -> None:
        """
        The property's symmetric peer.

        :type: None
        """
    @property
    def symmetryArguments(self) -> None:
        """
        Dictionary with property symmetry arguments.

        Although this property is marked read-only, you can modify the contents to add, change, and clear symmetry arguments.

        :type: None
        """
    @property
    def symmetryFunction(self) -> None:
        """
        The property's symmetry function.

        :type: None
        """
    @property
    def variability(self) -> None:
        """
        Returns the variability of the property.

        An attribute's variability may be Varying
        Uniform, Config or Computed.
        For an attribute, the default is Varying, for a relationship the default is Uniform.

        Varying relationships may be directly authored 'animating' targetpaths over time.
        Varying attributes may be directly authored, animated and 
        affected on by Actions.  They are the most flexible.

        Uniform attributes may be authored only with non-animated values
        (default values).  They cannot be affected by Actions, but they
        can be connected to other Uniform attributes.

        Config attributes are the same as Uniform except that a Prim
        can choose to alter its collection of built-in properties based
        on the values of its Config attributes.

        Computed attributes may not be authored in scene description.
        Prims determine the values of their Computed attributes through
        Prim-specific computation.  They may not be connected.

        :type: None
        """
    AssetInfoKey = 'assetInfo'
    CommentKey = 'comment'
    CustomDataKey = 'customData'
    CustomKey = 'custom'
    DisplayGroupKey = 'displayGroup'
    DisplayNameKey = 'displayName'
    DocumentationKey = 'documentation'
    HiddenKey = 'hidden'
    PermissionKey = 'permission'
    PrefixKey = 'prefix'
    SymmetricPeerKey = 'symmetricPeer'
    SymmetryArgumentsKey = 'symmetryArguments'
    SymmetryFunctionKey = 'symmetryFunction'
    pass
class PseudoRootSpec(PrimSpec, Spec, Boost.Python.instance):
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    pass
class Reference(Boost.Python.instance):
    """
    Represents a reference and all its meta data.

    A reference is expressed on a prim in a given layer and it identifies
    a prim in a layer stack. All opinions in the namespace hierarchy under
    the referenced prim will be composed with the opinions in the
    namespace hierarchy under the referencing prim.

    The asset path specifies the layer stack being referenced. If this
    asset path is non-empty, this reference is considered
    an'external'reference to the layer stack rooted at the specified
    layer. If this is empty, this reference is considered
    an'internal'reference to the layer stack containing (but not
    necessarily rooted at) the layer where the reference is authored.

    The prim path specifies the prim in the referenced layer stack from
    which opinions will be composed. If this prim path is empty, it will
    be considered a reference to the default prim specified in the root
    layer of the referenced layer stack  see SdfLayer::GetDefaultPrim.

    The meta data for a reference is its layer offset and custom data. The
    layer offset is an affine transformation applied to all anim splines
    in the referenced prim's namespace hierarchy, see SdfLayerOffset for
    details. Custom data is for use by plugins or other non-tools supplied
    extensions that need to be able to store data associated with
    references.
    """
    @staticmethod
    def IsInternal() -> bool: 
        """
        IsInternal() -> bool


        Returns ``true`` in the case of an internal reference.


        An internal reference is a reference with an empty asset path.
        """
    @property
    def assetPath(self) -> None:
        """
        type : None


        Sets the asset path for the root layer of the referenced layer stack.


        This may be set to an empty string to specify an internal reference.
        See SdfAssetPath for what characters are valid in ``assetPath`` . If
        ``assetPath`` contains invalid characters, issue an error and set this
        reference's asset path to the empty asset path.

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

        type : str


        Returns the asset path to the root layer of the referenced layer
        stack.


        This will be empty in the case of an internal reference.

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


        Sets the custom data associated with the reference.


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

        type : None


        Sets a custom data entry for the reference.


        If *value* is empty, then this removes the given custom data entry.

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

        type : VtDictionary


        Returns the custom data associated with the reference.

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


        Sets a new layer offset.

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

        type : LayerOffset


        Returns the layer offset associated with the reference.

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


        Sets the path of the referenced prim.


        This may be set to an empty path to specify a reference to the default
        prim in the referenced layer stack.

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

        type : Path


        Returns the path of the referenced prim.


        This will be empty if the referenced prim is the default prim
        specified in the referenced layer stack.

        :type: None
        """
    __instance_size__ = 80
    pass
class ReferenceListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class RelationshipSpec(PropertySpec, Spec, Boost.Python.instance):
    """
    A property that contains a reference to one or more SdfPrimSpec
    instances.

    A relationship may refer to one or more target prims or attributes.
    All targets of a single relationship are considered to be playing the
    same role. Note that ``role`` does not imply that the target prims or
    attributes are of the same ``type`` .

    Relationships may be annotated with relational attributes. Relational
    attributes are named SdfAttributeSpec objects containing values that
    describe the relationship. For example, point weights are commonly
    expressed as relational attributes.
    """
    @staticmethod
    def RemoveTargetPath(path, preserveTargetOrder) -> None: 
        """
        RemoveTargetPath(path, preserveTargetOrder) -> None


        Removes the specified target path.


        Removes the given target path and any relational attributes for the
        given target path. If ``preserveTargetOrder`` is ``true`` , Erase() is
        called on the list editor instead of RemoveItemEdits(). This preserves
        the ordered items list.


        Parameters
        ----------
        path : Path

        preserveTargetOrder : bool
        """
    @staticmethod
    def ReplaceTargetPath(oldPath, newPath) -> None: 
        """
        ReplaceTargetPath(oldPath, newPath) -> None


        Updates the specified target path.


        Replaces the path given by ``oldPath`` with the one specified by
        ``newPath`` . Relational attributes are updated if necessary.


        Parameters
        ----------
        oldPath : Path

        newPath : Path
        """
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    @property
    def noLoadHint(self) -> None:
        """
        whether the target must be loaded to load the prim this
        relationship is attached to.

        :type: None
        """
    @property
    def targetPathList(self) -> None:
        """
        A PathListEditor for the relationship's target paths.

        The list of the target paths for this relationship may be
        modified with this PathListEditor.

        A PathListEditor may express a list either as an explicit 
        value or as a set of list editing operations.  See PathListEditor 
        for more information.

        :type: None
        """
    TargetsKey = 'targetPaths'
    pass
class Spec(Boost.Python.instance):
    """
    Base class for all Sdf spec classes.
    """
    @staticmethod
    def ClearInfo(*args, **kwargs) -> None: 
        """
        key : string
        nClears the value for scene spec info with the given key. After calling this, HasInfo() will return false. To make HasInfo() return true, set a value for that scene spec info.
        """
    @staticmethod
    def GetAsText(*args, **kwargs) -> None: ...
    @staticmethod
    def GetFallbackForInfo(*args, **kwargs) -> None: 
        """
        key : string

        Returns the fallback value for the given key. 
        """
    @staticmethod
    def GetInfo(key) -> VtValue: 
        """
        GetInfo(key) -> VtValue


        Gets the value for the given metadata key.


        This is interim API which is likely to change. Only editors with an
        immediate specific need (like the Inspector) should use this API.


        Parameters
        ----------
        key : str
        """
    @staticmethod
    def GetMetaDataDisplayGroup(key) -> str: 
        """
        GetMetaDataDisplayGroup(key) -> str


        Returns this metadata key's displayGroup.


        Parameters
        ----------
        key : str
        """
    @staticmethod
    def GetMetaDataInfoKeys() -> list[str]: 
        """
        GetMetaDataInfoKeys() -> list[str]


        Returns the list of metadata info keys for this object.


        This is not the complete list of keys, it is only those that should be
        considered to be metadata by inspectors or other presentation UI.

        This is interim API which is likely to change. Only editors with an
        immediate specific need (like the Inspector) should use this API.
        """
    @staticmethod
    def GetTypeForInfo(*args, **kwargs) -> None: 
        """
        key : string

        Returns the type of value for the given key. 
        """
    @staticmethod
    def HasInfo(key) -> bool: 
        """
        key : string

        Returns whether there is a setting for the scene spec info with the given key.

        When asked for a value for one of its scene spec info, a valid value will always be returned. But if this API returns false for a scene spec info, the value of that info will be the defined default value. 

        (XXX: This may change such that it is an error to ask for a value when there is none).

        When dealing with a composedLayer, it is not necessary to worry about whether a scene spec info 'has a value' because the composed layer will always have a valid value, even if it is the default.

        A spec may or may not have an expressed value for some of its scene spec info.
        """
    @staticmethod
    def IsInert(*args, **kwargs) -> None: 
        """
        Indicates whether this spec has any significant data. If ignoreChildren is true, child scenegraph objects will be ignored.
        """
    @staticmethod
    def ListInfoKeys() -> list[str]: 
        """
        ListInfoKeys() -> list[str]


        Returns the full list of info keys currently set on this object.



        This does not include fields that represent names of children.
        """
    @staticmethod
    def SetInfo(key, value) -> None: 
        """
        SetInfo(key, value) -> None


        Sets the value for the given metadata key.


        It is an error to pass a value that is not the correct type for that
        given key.

        This is interim API which is likely to change. Only editors with an
        immediate specific need (like the Inspector) should use this API.


        Parameters
        ----------
        key : str

        value : VtValue
        """
    @staticmethod
    def SetInfoDictionaryValue(dictionaryKey, entryKey, value) -> None: 
        """
        SetInfoDictionaryValue(dictionaryKey, entryKey, value) -> None


        Sets the value for ``entryKey`` to ``value`` within the dictionary
        with the given metadata key ``dictionaryKey`` .


        Parameters
        ----------
        dictionaryKey : str

        entryKey : str

        value : VtValue
        """
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    @property
    def isInert(self) -> None:
        """
        Indicates whether this spec has any significant data. This is for backwards compatibility, use IsInert instead.

        Compatibility note: prior to presto 1.9, isInert (then isEmpty) was true for otherwise inert PrimSpecs with inert inherits, references, or variant sets. isInert is now false in such conditions.

        :type: None
        """
    @property
    def layer(self) -> None:
        """
        The owning layer.

        :type: None
        """
    @property
    def path(self) -> None:
        """
        The absolute scene path.

        :type: None
        """
    pass
class SpecType(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.SpecTypeUnknown, Sdf.SpecTypeAttribute, Sdf.SpecTypeConnection, Sdf.SpecTypeExpression, Sdf.SpecTypeMapper, Sdf.SpecTypeMapperArg, Sdf.SpecTypePrim, Sdf.SpecTypePseudoRoot, Sdf.SpecTypeRelationship, Sdf.SpecTypeRelationshipTarget, Sdf.SpecTypeVariant, Sdf.SpecTypeVariantSet)
    pass
class Specifier(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.SpecifierDef, Sdf.SpecifierOver, Sdf.SpecifierClass)
    pass
class StringListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class TimeCode(Boost.Python.instance):
    """
    Value type that represents a time code. It's equivalent to a double
    type value but is used to indicate that this value should be resolved
    by any time based value resolution.
    """
    @staticmethod
    def GetValue() -> float: 
        """
        GetValue() -> float


        Return the time value.
        """
    __instance_size__ = 24
    pass
class TimeCodeArray(Boost.Python.instance):
    """
    An array of type SdfTimeCode.
    """
    _isVtArray = True
    pass
class TokenListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class UInt64ListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class UIntListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class UnregisteredValue(Boost.Python.instance):
    """
    Stores a representation of the value for an unregistered metadata
    field encountered during text layer parsing.

    This provides the ability to serialize this data to a layer, as well
    as limited inspection and editing capabilities (e.g., moving this data
    to a different spec or field) even when the data type of the value
    isn't known.
    """
    @property
    def value(self) -> None:
        """
        type : VtValue


        Returns the wrapped VtValue specified in the constructor.

        :type: None
        """
    __instance_size__ = 32
    pass
class UnregisteredValueListOp(Boost.Python.instance):
    @staticmethod
    def ApplyOperations(*args, **kwargs) -> None: ...
    @staticmethod
    def Clear(*args, **kwargs) -> None: ...
    @staticmethod
    def ClearAndMakeExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def Create(*args, **kwargs) -> None: ...
    @staticmethod
    def CreateExplicit(*args, **kwargs) -> None: ...
    @staticmethod
    def GetAddedOrExplicitItems(*args, **kwargs) -> None: ...
    @staticmethod
    def HasItem(*args, **kwargs) -> None: ...
    @property
    def addedItems(self) -> None:
        """
        :type: None
        """
    @property
    def appendedItems(self) -> None:
        """
        :type: None
        """
    @property
    def deletedItems(self) -> None:
        """
        :type: None
        """
    @property
    def explicitItems(self) -> None:
        """
        :type: None
        """
    @property
    def isExplicit(self) -> None:
        """
        :type: None
        """
    @property
    def orderedItems(self) -> None:
        """
        :type: None
        """
    @property
    def prependedItems(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 168
    pass
class ValueBlock(Boost.Python.instance):
    """
    A special value type that can be used to explicitly author an opinion
    for an attribute's default value or time sample value that represents
    having no value. Note that this is different from not having a value
    authored.

    One could author such a value in two ways.

    .. code-block:: text

      attribute->SetDefaultValue(VtValue(SdfValueBlock());
      \.\.\.
      layer->SetTimeSample(attribute->GetPath(), 101, VtValue(SdfValueBlock()));
    """
    __instance_size__ = 24
    pass
class ValueRoleNames(Boost.Python.instance):
    Color = 'Color'
    EdgeIndex = 'EdgeIndex'
    FaceIndex = 'FaceIndex'
    Frame = 'Frame'
    Normal = 'Normal'
    Point = 'Point'
    PointIndex = 'PointIndex'
    TextureCoordinate = 'TextureCoordinate'
    Transform = 'Transform'
    Vector = 'Vector'
    pass
class ValueTypeName(Boost.Python.instance):
    """
    Represents a value type name, i.e. an attribute's type name. Usually,
    a value type name associates a string with a ``TfType`` and an
    optional role, along with additional metadata. A schema registers all
    known value type names and may register multiple names for the same
    TfType and role pair. All name strings for a given pair are
    collectively called its aliases.

    A value type name may also represent just a name string, without a
    ``TfType`` , role or other metadata. This is currently used
    exclusively to unserialize and re-serialize an attribute's type name
    where that name is not known to the schema.

    Because value type names can have aliases and those aliases may change
    in the future, clients should avoid using the value type name's string
    representation except to report human readable messages and when
    serializing. Clients can look up a value type name by string using
    ``SdfSchemaBase::FindType()`` and shouldn't otherwise need the string.
    Aliases compare equal, even if registered by different schemas.
    """
    @property
    def aliasesAsStrings(self) -> None:
        """
        :type: None
        """
    @property
    def arrayType(self) -> None:
        """
        type : ValueTypeName


        Returns the array version of this type name if it's an scalar type
        name, otherwise returns this type name.


        If there is no array type name then this returns the invalid type
        name.

        :type: None
        """
    @property
    def cppTypeName(self) -> None:
        """
        :type: None
        """
    @property
    def defaultUnit(self) -> None:
        """
        type : Enum


        Returns the default unit enum for the type.

        :type: None
        """
    @property
    def defaultValue(self) -> None:
        """
        type : VtValue


        Returns the default value for the type.

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


        Returns ``true`` iff this type is an array.


        The invalid type is considered neither scalar nor array.

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


        Returns ``true`` iff this type is a scalar.


        The invalid type is considered neither scalar nor array.

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


        Returns the type's role.

        :type: None
        """
    @property
    def scalarType(self) -> None:
        """
        type : ValueTypeName


        Returns the scalar version of this type name if it's an array type
        name, otherwise returns this type name.


        If there is no scalar type name then this returns the invalid type
        name.

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


        Returns the ``TfType`` of the type.

        :type: None
        """
    pass
class ValueTypeNames(Boost.Python.instance):
    @staticmethod
    def Find(*args, **kwargs) -> None: ...
    Asset: pxr.Sdf.ValueTypeName
    AssetArray: pxr.Sdf.ValueTypeName
    Bool: pxr.Sdf.ValueTypeName
    BoolArray: pxr.Sdf.ValueTypeName
    Color3d: pxr.Sdf.ValueTypeName
    Color3dArray: pxr.Sdf.ValueTypeName
    Color3f: pxr.Sdf.ValueTypeName
    Color3fArray: pxr.Sdf.ValueTypeName
    Color3h: pxr.Sdf.ValueTypeName
    Color3hArray: pxr.Sdf.ValueTypeName
    Color4d: pxr.Sdf.ValueTypeName
    Color4dArray: pxr.Sdf.ValueTypeName
    Color4f: pxr.Sdf.ValueTypeName
    Color4fArray: pxr.Sdf.ValueTypeName
    Color4h: pxr.Sdf.ValueTypeName
    Color4hArray: pxr.Sdf.ValueTypeName
    Double: pxr.Sdf.ValueTypeName
    Double2: pxr.Sdf.ValueTypeName
    Double2Array: pxr.Sdf.ValueTypeName
    Double3: pxr.Sdf.ValueTypeName
    Double3Array: pxr.Sdf.ValueTypeName
    Double4: pxr.Sdf.ValueTypeName
    Double4Array: pxr.Sdf.ValueTypeName
    DoubleArray: pxr.Sdf.ValueTypeName
    Float: pxr.Sdf.ValueTypeName
    Float2: pxr.Sdf.ValueTypeName
    Float2Array: pxr.Sdf.ValueTypeName
    Float3: pxr.Sdf.ValueTypeName
    Float3Array: pxr.Sdf.ValueTypeName
    Float4: pxr.Sdf.ValueTypeName
    Float4Array: pxr.Sdf.ValueTypeName
    FloatArray: pxr.Sdf.ValueTypeName
    Frame4d: pxr.Sdf.ValueTypeName
    Frame4dArray: pxr.Sdf.ValueTypeName
    Half: pxr.Sdf.ValueTypeName
    Half2: pxr.Sdf.ValueTypeName
    Half2Array: pxr.Sdf.ValueTypeName
    Half3: pxr.Sdf.ValueTypeName
    Half3Array: pxr.Sdf.ValueTypeName
    Half4: pxr.Sdf.ValueTypeName
    Half4Array: pxr.Sdf.ValueTypeName
    HalfArray: pxr.Sdf.ValueTypeName
    Int: pxr.Sdf.ValueTypeName
    Int2: pxr.Sdf.ValueTypeName
    Int2Array: pxr.Sdf.ValueTypeName
    Int3: pxr.Sdf.ValueTypeName
    Int3Array: pxr.Sdf.ValueTypeName
    Int4: pxr.Sdf.ValueTypeName
    Int4Array: pxr.Sdf.ValueTypeName
    Int64: pxr.Sdf.ValueTypeName
    Int64Array: pxr.Sdf.ValueTypeName
    IntArray: pxr.Sdf.ValueTypeName
    Matrix2d: pxr.Sdf.ValueTypeName
    Matrix2dArray: pxr.Sdf.ValueTypeName
    Matrix3d: pxr.Sdf.ValueTypeName
    Matrix3dArray: pxr.Sdf.ValueTypeName
    Matrix4d: pxr.Sdf.ValueTypeName
    Matrix4dArray: pxr.Sdf.ValueTypeName
    Normal3d: pxr.Sdf.ValueTypeName
    Normal3dArray: pxr.Sdf.ValueTypeName
    Normal3f: pxr.Sdf.ValueTypeName
    Normal3fArray: pxr.Sdf.ValueTypeName
    Normal3h: pxr.Sdf.ValueTypeName
    Normal3hArray: pxr.Sdf.ValueTypeName
    Point3d: pxr.Sdf.ValueTypeName
    Point3dArray: pxr.Sdf.ValueTypeName
    Point3f: pxr.Sdf.ValueTypeName
    Point3fArray: pxr.Sdf.ValueTypeName
    Point3h: pxr.Sdf.ValueTypeName
    Point3hArray: pxr.Sdf.ValueTypeName
    Quatd: pxr.Sdf.ValueTypeName
    QuatdArray: pxr.Sdf.ValueTypeName
    Quatf: pxr.Sdf.ValueTypeName
    QuatfArray: pxr.Sdf.ValueTypeName
    Quath: pxr.Sdf.ValueTypeName
    QuathArray: pxr.Sdf.ValueTypeName
    String: pxr.Sdf.ValueTypeName
    StringArray: pxr.Sdf.ValueTypeName
    TexCoord2d: pxr.Sdf.ValueTypeName
    TexCoord2dArray: pxr.Sdf.ValueTypeName
    TexCoord2f: pxr.Sdf.ValueTypeName
    TexCoord2fArray: pxr.Sdf.ValueTypeName
    TexCoord2h: pxr.Sdf.ValueTypeName
    TexCoord2hArray: pxr.Sdf.ValueTypeName
    TexCoord3d: pxr.Sdf.ValueTypeName
    TexCoord3dArray: pxr.Sdf.ValueTypeName
    TexCoord3f: pxr.Sdf.ValueTypeName
    TexCoord3fArray: pxr.Sdf.ValueTypeName
    TexCoord3h: pxr.Sdf.ValueTypeName
    TexCoord3hArray: pxr.Sdf.ValueTypeName
    TimeCode: pxr.Sdf.ValueTypeName
    TimeCodeArray: pxr.Sdf.ValueTypeName
    Token: pxr.Sdf.ValueTypeName
    TokenArray: pxr.Sdf.ValueTypeName
    UChar: pxr.Sdf.ValueTypeName
    UCharArray: pxr.Sdf.ValueTypeName
    UInt: pxr.Sdf.ValueTypeName
    UInt64: pxr.Sdf.ValueTypeName
    UInt64Array: pxr.Sdf.ValueTypeName
    UIntArray: pxr.Sdf.ValueTypeName
    Vector3d: pxr.Sdf.ValueTypeName
    Vector3dArray: pxr.Sdf.ValueTypeName
    Vector3f: pxr.Sdf.ValueTypeName
    Vector3fArray: pxr.Sdf.ValueTypeName
    Vector3h: pxr.Sdf.ValueTypeName
    Vector3hArray: pxr.Sdf.ValueTypeName
    pass
class Variability(pxr.Tf.Tf_PyEnumWrapper, pxr.Tf.Enum, Boost.Python.instance):
    @staticmethod
    def GetValueFromName(*args, **kwargs) -> None: ...
    _baseName = ''
    allValues: tuple # value = (Sdf.VariabilityVarying, Sdf.VariabilityUniform)
    pass
class VariantSetSpec(Spec, Boost.Python.instance):
    """
    Represents a coherent set of alternate representations for part of a
    scene.

    An SdfPrimSpec object may contain one or more named SdfVariantSetSpec
    objects that define variations on the prim.

    An SdfVariantSetSpec object contains one or more named SdfVariantSpec
    objects. It may also define the name of one of its variants to be used
    by default.

    When a prim references another prim, the referencing prim may specify
    one of the variants from each of the variant sets of the target prim.
    The chosen variant from each set (or the default variant from those
    sets that the referencing prim does not explicitly specify) is
    composited over the target prim, and then the referencing prim is
    composited over the result.
    """
    @staticmethod
    def RemoveVariant(variant) -> None: 
        """
        RemoveVariant(variant) -> None


        Removes ``variant`` from the list of variants.


        If the variant set does not currently own ``variant`` , no action is
        taken.


        Parameters
        ----------
        variant : VariantSpec
        """
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    @property
    def name(self) -> None:
        """
        The variant set's name.

        :type: None
        """
    @property
    def owner(self) -> None:
        """
        The prim that this variant set belongs to.

        :type: None
        """
    @property
    def variantList(self) -> None:
        """
        The variants in this variant set as a list.

        :type: None
        """
    @property
    def variants(self) -> None:
        """
        The variants in this variant set as a dict.

        :type: None
        """
    pass
class VariantSpec(Spec, Boost.Python.instance):
    """
    Represents a single variant in a variant set.

    A variant contains a prim. This prim is the root prim of the variant.

    SdfVariantSpecs are value objects. This means they are immutable once
    created and they are passed by copy-in APIs. To change a variant spec,
    you make a new one and replace the existing one.
    """
    @staticmethod
    def GetVariantNames(name) -> list[str]: 
        """
        GetVariantNames(name) -> list[str]


        Returns list of variant names for the given variant set.


        Parameters
        ----------
        name : str
        """
    @property
    def expired(self) -> None:
        """
        :type: None
        """
    @property
    def name(self) -> None:
        """
        The variant's name.

        :type: None
        """
    @property
    def owner(self) -> None:
        """
        The variant set that this variant belongs to.

        :type: None
        """
    @property
    def primSpec(self) -> None:
        """
        The root prim of this variant.

        :type: None
        """
    @property
    def variantSets(self) -> None:
        """
        type : SdfVariantSetsProxy


        Returns the nested variant sets.


        The result maps variant set names to variant sets. Variant sets may be
        removed through the proxy.

        :type: None
        """
    pass
def Cat(*args, **kwargs) -> None:
    pass
def ComputeAssetPathRelativeToLayer(*args, **kwargs) -> None:
    pass
def ConvertToValidMetadataDictionary(*args, **kwargs) -> None:
    pass
def ConvertUnit(*args, **kwargs) -> None:
    """
    Convert a unit of measurement to a compatible unit.
    """
def CopySpec(*args, **kwargs) -> None:
    pass
def CreatePrimInLayer(*args, **kwargs) -> None:
    pass
def CreateVariantInLayer(*args, **kwargs) -> None:
    pass
def DefaultUnit(*args, **kwargs) -> None:
    """
    For a given unit of measurement get the default compatible unit.

    For a given typeName ('Vector', 'Point' etc.) get the default unit of measurement.
    """
def Equal(*args, **kwargs) -> None:
    pass
def GetNameForUnit(*args, **kwargs) -> None:
    pass
def GetTypeForValueTypeName(*args, **kwargs) -> None:
    pass
def GetUnitFromName(*args, **kwargs) -> None:
    pass
def GetValueTypeNameForValue(*args, **kwargs) -> None:
    pass
def JustCreatePrimAttributeInLayer(*args, **kwargs) -> None:
    pass
def JustCreatePrimInLayer(*args, **kwargs) -> None:
    pass
def NotEqual(*args, **kwargs) -> None:
    pass
def UnitCategory(*args, **kwargs) -> None:
    """
    For a given unit of measurement get the unit category.
    """
def ValueHasValidType(*args, **kwargs) -> None:
    pass
def _DumpPathStats(*args, **kwargs) -> None:
    pass
def _PathGetDebuggerPathText(*args, **kwargs) -> None:
    pass
def _PathStress(*args, **kwargs) -> None:
    pass
def _TestTakeOwnership(*args, **kwargs) -> None:
    pass
AngularUnitDegrees: pxr.Sdf.AngularUnit # value = Sdf.AngularUnitDegrees
AngularUnitRadians: pxr.Sdf.AngularUnit # value = Sdf.AngularUnitRadians
AuthoringErrorUnrecognizedFields: pxr.Sdf.AuthoringError # value = Sdf.AuthoringErrorUnrecognizedFields
AuthoringErrorUnrecognizedSpecType: pxr.Sdf.AuthoringError # value = Sdf.AuthoringErrorUnrecognizedSpecType
DimensionlessUnitDefault: pxr.Sdf.DimensionlessUnit # value = Sdf.DimensionlessUnitDefault
DimensionlessUnitPercent: pxr.Sdf.DimensionlessUnit # value = Sdf.DimensionlessUnitPercent
LengthUnitCentimeter: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitCentimeter
LengthUnitDecimeter: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitDecimeter
LengthUnitFoot: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitFoot
LengthUnitInch: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitInch
LengthUnitKilometer: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitKilometer
LengthUnitMeter: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitMeter
LengthUnitMile: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitMile
LengthUnitMillimeter: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitMillimeter
LengthUnitYard: pxr.Sdf.LengthUnit # value = Sdf.LengthUnitYard
ListOpTypeAdded: pxr.Sdf.ListOpType # value = Sdf.ListOpTypeAdded
ListOpTypeAppended: pxr.Sdf.ListOpType # value = Sdf.ListOpTypeAppended
ListOpTypeDeleted: pxr.Sdf.ListOpType # value = Sdf.ListOpTypeDeleted
ListOpTypeExplicit: pxr.Sdf.ListOpType # value = Sdf.ListOpTypeExplicit
ListOpTypeOrdered: pxr.Sdf.ListOpType # value = Sdf.ListOpTypeOrdered
ListOpTypePrepended: pxr.Sdf.ListOpType # value = Sdf.ListOpTypePrepended
PermissionPrivate: pxr.Sdf.Permission # value = Sdf.PermissionPrivate
PermissionPublic: pxr.Sdf.Permission # value = Sdf.PermissionPublic
SpecTypeAttribute: pxr.Sdf.SpecType # value = Sdf.SpecTypeAttribute
SpecTypeConnection: pxr.Sdf.SpecType # value = Sdf.SpecTypeConnection
SpecTypeExpression: pxr.Sdf.SpecType # value = Sdf.SpecTypeExpression
SpecTypeMapper: pxr.Sdf.SpecType # value = Sdf.SpecTypeMapper
SpecTypeMapperArg: pxr.Sdf.SpecType # value = Sdf.SpecTypeMapperArg
SpecTypePrim: pxr.Sdf.SpecType # value = Sdf.SpecTypePrim
SpecTypePseudoRoot: pxr.Sdf.SpecType # value = Sdf.SpecTypePseudoRoot
SpecTypeRelationship: pxr.Sdf.SpecType # value = Sdf.SpecTypeRelationship
SpecTypeRelationshipTarget: pxr.Sdf.SpecType # value = Sdf.SpecTypeRelationshipTarget
SpecTypeUnknown: pxr.Sdf.SpecType # value = Sdf.SpecTypeUnknown
SpecTypeVariant: pxr.Sdf.SpecType # value = Sdf.SpecTypeVariant
SpecTypeVariantSet: pxr.Sdf.SpecType # value = Sdf.SpecTypeVariantSet
SpecifierClass: pxr.Sdf.Specifier # value = Sdf.SpecifierClass
SpecifierDef: pxr.Sdf.Specifier # value = Sdf.SpecifierDef
SpecifierOver: pxr.Sdf.Specifier # value = Sdf.SpecifierOver
VariabilityUniform: pxr.Sdf.Variability # value = Sdf.VariabilityUniform
VariabilityVarying: pxr.Sdf.Variability # value = Sdf.VariabilityVarying
__MFB_FULL_PACKAGE_NAME = 'sdf'
