def Execute(result):
   result["AssetPath"].__doc__ = """
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.

"""
   result["AssetPath"].__init__.func_doc = """__init__()


Construct an empty asset path.




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

__init__(path)


Construct an asset path with ``path`` and no associated resolved path.


If the passed ``path`` is not valid UTF-8 or contains C0 or C1 control
characters, raise a TfError and return the default-constructed empty
asset path.


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



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

__init__(path, resolvedPath)


Construct an asset path with ``path`` and an associated
``resolvedPath`` .


If either the passed \path or ``resolvedPath`` are not valid UTF-8 or
either contain C0 or C1 control characters, raise a TfError and return
the default-constructed empty asset path.


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

resolvedPath : str


"""
   result["AttributeSpec"].__doc__ = """
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.

"""
   result["AttributeSpec"].HasColorSpace.func_doc = """HasColorSpace() -> bool


Returns true if this attribute has a colorSpace value authored.



"""
   result["AttributeSpec"].ClearColorSpace.func_doc = """ClearColorSpace() -> None


Clears the colorSpace metadata value set on this attribute.



"""
   result["BatchNamespaceEdit"].__doc__ = """
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.

"""
   result["BatchNamespaceEdit"].__init__.func_doc = """__init__()


Create an empty sequence of edits.




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

__init__(arg1)


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



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

__init__(arg1)


Parameters
----------
arg1 : list[SdfNamespaceEdit]


"""
   result["BatchNamespaceEdit"].Add.func_doc = """Add(edit) -> None


Add a namespace edit.


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



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

Add(currentPath, newPath, index) -> None


Add a namespace edit.


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

newPath : NamespaceEdit.Path

index : NamespaceEdit.Index


"""
   result["BatchNamespaceEdit"].Process.func_doc = """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


"""
   result["ChangeBlock"].__doc__ = """
**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.

"""
   result["ChangeBlock"].__init__.func_doc = """__init__()



"""
   result["CleanupEnabler"].__doc__ = """
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.
  }


"""
   result["CleanupEnabler"].__init__.func_doc = """__init__()



"""
   result["FastUpdateList"].__doc__ = """"""
   result["FileFormat"].__doc__ = """
Base class for file format implementations.

"""
   result["FileFormat"].GetFileExtensions.func_doc = """GetFileExtensions() -> list[str]


Returns a list of extensions that this format supports.



"""
   result["FileFormat"].IsSupportedExtension.func_doc = """IsSupportedExtension(extension) -> bool


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


Parameters
----------
extension : str


"""
   result["FileFormat"].IsPackage.func_doc = """IsPackage() -> bool


Returns true if this file format is a package containing other assets.



"""
   result["FileFormat"].CanRead.func_doc = """CanRead(file) -> bool


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


Parameters
----------
file : str


"""
   result["FileFormat"].GetFileExtension.func_doc = """**classmethod** GetFileExtension(s) -> str


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


Parameters
----------
s : str


"""
   result["FileFormat"].FindAllFileFormatExtensions.func_doc = """**classmethod** FindAllFileFormatExtensions() -> set[str]


Returns a set containing the extension(s) corresponding to all
registered file formats.



"""
   result["FileFormat"].FindById.func_doc = """**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


"""
   result["FileFormat"].FindByExtension.func_doc = """**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



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

FindByExtension(path, args) -> FileFormat


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


"""
   result["Layer"].__doc__ = """
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.

"""
   result["Layer"].GetFileFormat.func_doc = """GetFileFormat() -> FileFormat


Returns the file format used by this layer.



"""
   result["Layer"].GetFileFormatArguments.func_doc = """GetFileFormatArguments() -> FileFormatArguments


Returns the file format-specific arguments used during the
construction of this layer.



"""
   result["Layer"].StreamsData.func_doc = """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.



"""
   result["Layer"].IsDetached.func_doc = """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.



"""
   result["Layer"].TransferContent.func_doc = """TransferContent(layer) -> None


Copies the content of the given layer into this layer.


Source layer is unmodified.


Parameters
----------
layer : Layer


"""
   result["Layer"].CreateNew.func_doc = """**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



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

CreateNew(fileFormat, identifier, args) -> Layer


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


"""
   result["Layer"].New.func_doc = """**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


"""
   result["Layer"].FindOrOpen.func_doc = """**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


"""
   result["Layer"].FindOrOpenRelativeToLayer.func_doc = """**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


"""
   result["Layer"].OpenAsAnonymous.func_doc = """**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


"""
   result["Layer"].CreateAnonymous.func_doc = """**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



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

CreateAnonymous(tag, format, args) -> Layer


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


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

format : FileFormat

args : FileFormatArguments


"""
   result["Layer"].IsAnonymousLayerIdentifier.func_doc = """**classmethod** IsAnonymousLayerIdentifier(identifier) -> bool


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


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


"""
   result["Layer"].GetDisplayNameFromIdentifier.func_doc = """**classmethod** GetDisplayNameFromIdentifier(identifier) -> str


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


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


"""
   result["Layer"].Save.func_doc = """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


"""
   result["Layer"].Export.func_doc = """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


"""
   result["Layer"].ImportFromString.func_doc = """ImportFromString(string) -> bool


Reads this layer from the given string.


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


Parameters
----------
string : str


"""
   result["Layer"].Clear.func_doc = """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.



"""
   result["Layer"].Reload.func_doc = """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


"""
   result["Layer"].Import.func_doc = """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


"""
   result["Layer"].ReloadLayers.func_doc = """**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


"""
   result["Layer"].UpdateExternalReference.func_doc = """UpdateExternalReference(oldAssetPath, newAssetPath) -> bool


Deprecated

Use UpdateCompositionAssetDependency instead.


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

newAssetPath : str


"""
   result["Layer"].GetCompositionAssetDependencies.func_doc = """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.



"""
   result["Layer"].UpdateCompositionAssetDependency.func_doc = """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


"""
   result["Layer"].GetExternalAssetDependencies.func_doc = """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.



"""
   result["Layer"].UpdateAssetInfo.func_doc = """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.



"""
   result["Layer"].GetDisplayName.func_doc = """GetDisplayName() -> str


Returns the layer's display name.


The display name is the base filename of the identifier.



"""
   result["Layer"].GetAssetName.func_doc = """GetAssetName() -> str


Returns the asset name associated with this layer.



"""
   result["Layer"].GetAssetInfo.func_doc = """GetAssetInfo() -> VtValue


Returns resolve information from the last time the layer identifier
was resolved.



"""
   result["Layer"].ComputeAbsolutePath.func_doc = """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


"""
   result["Layer"].SplitIdentifier.func_doc = """**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


"""
   result["Layer"].CreateIdentifier.func_doc = """**classmethod** CreateIdentifier(layerPath, arguments) -> str


Joins the given layer path and arguments into an identifier.


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

arguments : FileFormatArguments


"""
   result["Layer"].Traverse.func_doc = """Traverse(path, func) -> None


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

func : TraversalFunction


"""
   result["Layer"].HasColorConfiguration.func_doc = """HasColorConfiguration() -> bool


Returns true if color configuration metadata is set in this layer.



GetColorConfiguration() , SetColorConfiguration()



"""
   result["Layer"].ClearColorConfiguration.func_doc = """ClearColorConfiguration() -> None


Clears the color configuration metadata authored in this layer.



HasColorConfiguration() , SetColorConfiguration()



"""
   result["Layer"].HasColorManagementSystem.func_doc = """HasColorManagementSystem() -> bool


Returns true if colorManagementSystem metadata is set in this layer.



GetColorManagementSystem() , SetColorManagementSystem()



"""
   result["Layer"].ClearColorManagementSystem.func_doc = """ClearColorManagementSystem() -> None


Clears the'colorManagementSystem'metadata authored in this layer.



HascolorManagementSystem(), SetColorManagementSystem()



"""
   result["Layer"].ClearDefaultPrim.func_doc = """ClearDefaultPrim() -> None


Clear the default prim metadata for this layer.


See GetDefaultPrim() and SetDefaultPrim() .



"""
   result["Layer"].HasDefaultPrim.func_doc = """HasDefaultPrim() -> bool


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


See GetDefaultPrim() and SetDefaultPrim() .



"""
   result["Layer"].HasStartTimeCode.func_doc = """HasStartTimeCode() -> bool


Returns true if the layer has a startTimeCode opinion.



"""
   result["Layer"].ClearStartTimeCode.func_doc = """ClearStartTimeCode() -> None


Clear the startTimeCode opinion.



"""
   result["Layer"].HasEndTimeCode.func_doc = """HasEndTimeCode() -> bool


Returns true if the layer has an endTimeCode opinion.



"""
   result["Layer"].ClearEndTimeCode.func_doc = """ClearEndTimeCode() -> None


Clear the endTimeCode opinion.



"""
   result["Layer"].HasTimeCodesPerSecond.func_doc = """HasTimeCodesPerSecond() -> bool


Returns true if the layer has a timeCodesPerSecond opinion.



"""
   result["Layer"].ClearTimeCodesPerSecond.func_doc = """ClearTimeCodesPerSecond() -> None


Clear the timeCodesPerSecond opinion.



"""
   result["Layer"].HasFramesPerSecond.func_doc = """HasFramesPerSecond() -> bool


Returns true if the layer has a frames per second opinion.



"""
   result["Layer"].ClearFramesPerSecond.func_doc = """ClearFramesPerSecond() -> None


Clear the framesPerSecond opinion.



"""
   result["Layer"].HasFramePrecision.func_doc = """HasFramePrecision() -> bool


Returns true if the layer has a frames precision opinion.



"""
   result["Layer"].ClearFramePrecision.func_doc = """ClearFramePrecision() -> None


Clear the framePrecision opinion.



"""
   result["Layer"].HasOwner.func_doc = """HasOwner() -> bool


Returns true if the layer has an owner opinion.



"""
   result["Layer"].ClearOwner.func_doc = """ClearOwner() -> None


Clear the owner opinion.



"""
   result["Layer"].HasSessionOwner.func_doc = """HasSessionOwner() -> bool


Returns true if the layer has a session owner opinion.



"""
   result["Layer"].ClearSessionOwner.func_doc = """ClearSessionOwner() -> None



"""
   result["Layer"].HasCustomLayerData.func_doc = """HasCustomLayerData() -> bool


Returns true if CustomLayerData is authored on the layer.



"""
   result["Layer"].ClearCustomLayerData.func_doc = """ClearCustomLayerData() -> None


Clears out the CustomLayerData dictionary associated with this layer.



"""
   result["Layer"].ScheduleRemoveIfInert.func_doc = """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


"""
   result["Layer"].RemoveInertSceneDescription.func_doc = """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.



"""
   result["Layer"].ApplyRootPrimOrder.func_doc = """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]


"""
   result["Layer"].SetDetachedLayerRules.func_doc = """**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


"""
   result["Layer"].GetDetachedLayerRules.func_doc = """**classmethod** GetDetachedLayerRules() -> DetachedLayerRules


Returns the current rules for the detached layer set.



"""
   result["Layer"].IsIncludedByDetachedLayerRules.func_doc = """**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


"""
   result["Layer"].IsMuted.func_doc = """**classmethod** IsMuted() -> bool


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




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

IsMuted(path) -> bool


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


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


"""
   result["Layer"].SetMuted.func_doc = """SetMuted(muted) -> None


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


Parameters
----------
muted : bool


"""
   result["Layer"].AddToMutedLayers.func_doc = """**classmethod** AddToMutedLayers(mutedPath) -> None


Add the specified path to the muted layers set.


Parameters
----------
mutedPath : str


"""
   result["Layer"].RemoveFromMutedLayers.func_doc = """**classmethod** RemoveFromMutedLayers(mutedPath) -> None


Remove the specified path from the muted layers set.


Parameters
----------
mutedPath : str


"""
   result["Layer"].GetObjectAtPath.func_doc = """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


"""
   result["Layer"].GetPrimAtPath.func_doc = """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


"""
   result["Layer"].GetPropertyAtPath.func_doc = """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


"""
   result["Layer"].GetAttributeAtPath.func_doc = """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


"""
   result["Layer"].GetRelationshipAtPath.func_doc = """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


"""
   result["Layer"].SetPermissionToEdit.func_doc = """SetPermissionToEdit(allow) -> None


Sets permission to edit.


Parameters
----------
allow : bool


"""
   result["Layer"].SetPermissionToSave.func_doc = """SetPermissionToSave(allow) -> None


Sets permission to save.


Parameters
----------
allow : bool


"""
   result["Layer"].CanApply.func_doc = """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]


"""
   result["Layer"].Apply.func_doc = """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


"""
   result["Layer"].ListAllTimeSamples.func_doc = """ListAllTimeSamples() -> set[float]



"""
   result["Layer"].ListTimeSamplesForPath.func_doc = """ListTimeSamplesForPath(path) -> set[float]


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


"""
   result["Layer"].GetBracketingTimeSamples.func_doc = """GetBracketingTimeSamples(time, tLower, tUpper) -> bool


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

tLower : float

tUpper : float


"""
   result["Layer"].GetNumTimeSamplesForPath.func_doc = """GetNumTimeSamplesForPath(path) -> int


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


"""
   result["Layer"].GetBracketingTimeSamplesForPath.func_doc = """GetBracketingTimeSamplesForPath(path, time, tLower, tUpper) -> bool


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

time : float

tLower : float

tUpper : float


"""
   result["Layer"].QueryTimeSample.func_doc = """QueryTimeSample(path, time, value) -> bool


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

time : float

value : VtValue



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

QueryTimeSample(path, time, value) -> bool


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

time : float

value : SdfAbstractDataValue



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

QueryTimeSample(path, time, data) -> bool


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

time : float

data : T


"""
   result["Layer"].SetTimeSample.func_doc = """SetTimeSample(path, time, value) -> None


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

time : float

value : VtValue



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

SetTimeSample(path, time, value) -> None


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

time : float

value : SdfAbstractDataConstValue



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

SetTimeSample(path, time, value) -> None


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

time : float

value : T


"""
   result["Layer"].EraseTimeSample.func_doc = """EraseTimeSample(path, time) -> None


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

time : float


"""
   result["LayerOffset"].__doc__ = """
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.

"""
   result["LayerOffset"].__init__.func_doc = """__init__(offset, scale)


Constructs a new SdfLayerOffset instance.


Parameters
----------
offset : float

scale : float


"""
   result["LayerOffset"].IsIdentity.func_doc = """IsIdentity() -> bool


Returns ``true`` if this is an identity transformation, with an offset
of 0.0 and a scale of 1.0.



"""
   result["LayerOffset"].GetInverse.func_doc = """GetInverse() -> LayerOffset


Gets the inverse offset, which performs the opposite transformation.



"""
   result["LayerTree"].__doc__ = """
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.

"""
   result["LayerTree"].__init__.func_doc = """__init__(layer, childTrees, cumulativeOffset)


Parameters
----------
layer : Layer

childTrees : list[SdfLayerTreeHandle]

cumulativeOffset : LayerOffset


"""
   result["NamespaceEdit"].__doc__ = """
A single namespace edit. It supports renaming, reparenting,
reparenting with a rename, reordering, and removal.

"""
   result["NamespaceEdit"].__init__.func_doc = """__init__()


The default edit maps the empty path to the empty path.




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

__init__(currentPath_, newPath_, index_)


The fully general edit.


Parameters
----------
currentPath_ : Path

newPath_ : Path

index_ : Index


"""
   result["NamespaceEdit"].Remove.func_doc = """**classmethod** Remove(currentPath) -> This


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


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


"""
   result["NamespaceEdit"].Rename.func_doc = """**classmethod** Rename(currentPath, name) -> This


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


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

name : str


"""
   result["NamespaceEdit"].Reorder.func_doc = """**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


"""
   result["NamespaceEdit"].Reparent.func_doc = """**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


"""
   result["NamespaceEdit"].ReparentAndRename.func_doc = """**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


"""
   result["NamespaceEditDetail"].__doc__ = """
Detailed information about a namespace edit.

"""
   result["NamespaceEditDetail"].Result.__doc__ = """
Validity of an edit.

"""
   result["NamespaceEditDetail"].__init__.func_doc = """__init__()




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

__init__(arg1, edit, reason)


Parameters
----------
arg1 : Result

edit : NamespaceEdit

reason : str


"""
   result["Notice"].__doc__ = """
Wrapper class for Sdf notices.

"""
   result["Path"].__doc__ = """
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).

"""
   result["Path"].__init__.func_doc = """__init__()


Constructs the default, empty path.




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

__init__(path)


Creates a path from the given string.


If the given string is not a well-formed path, this will raise a Tf
error. Note that passing an empty std::string() will also raise an
error; the correct way to get the empty path is SdfPath() .

Internal dot-dots will be resolved by removing the first dot-dot, the
element preceding it, and repeating until no internal dot-dots remain.

Note that most often new paths are expected to be created by asking
existing paths to return modified versions of themselves.


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



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

__init__(primNode)


Parameters
----------
primNode : Sdf_PathPrimNode



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

__init__(primPart, propPart)


Parameters
----------
primPart : Sdf_PathPrimNode

propPart : Sdf_PathPropNode



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

__init__(primPart, propPart)


Parameters
----------
primPart : Sdf_PathNode

propPart : Sdf_PathNode


"""
   result["Path"].IsAbsolutePath.func_doc = """IsAbsolutePath() -> bool


Returns whether the path is absolute.



"""
   result["Path"].IsAbsoluteRootPath.func_doc = """IsAbsoluteRootPath() -> bool


Return true if this path is the AbsoluteRootPath() .



"""
   result["Path"].IsPrimPath.func_doc = """IsPrimPath() -> bool


Returns whether the path identifies a prim.



"""
   result["Path"].IsAbsoluteRootOrPrimPath.func_doc = """IsAbsoluteRootOrPrimPath() -> bool


Returns whether the path identifies a prim or the absolute root.



"""
   result["Path"].IsRootPrimPath.func_doc = """IsRootPrimPath() -> bool


Returns whether the path identifies a root prim.


the path must be absolute and have a single element (for example
``/foo`` ).



"""
   result["Path"].IsPropertyPath.func_doc = """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.



"""
   result["Path"].IsPrimPropertyPath.func_doc = """IsPrimPropertyPath() -> bool


Returns whether the path identifies a prim's property.


A relational attribute is not a prim property.



"""
   result["Path"].IsNamespacedPropertyPath.func_doc = """IsNamespacedPropertyPath() -> bool


Returns whether the path identifies a namespaced property.


A namespaced property has colon embedded in its name.



"""
   result["Path"].IsPrimVariantSelectionPath.func_doc = """IsPrimVariantSelectionPath() -> bool


Returns whether the path identifies a variant selection for a prim.



"""
   result["Path"].ContainsPrimVariantSelection.func_doc = """ContainsPrimVariantSelection() -> bool


Returns whether the path or any of its parent paths identifies a
variant selection for a prim.



"""
   result["Path"].ContainsPropertyElements.func_doc = """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.



"""
   result["Path"].ContainsTargetPath.func_doc = """ContainsTargetPath() -> bool


Return true if this path is or has a prefix that's a target path or a
mapper path.



"""
   result["Path"].IsRelationalAttributePath.func_doc = """IsRelationalAttributePath() -> bool


Returns whether the path identifies a relational attribute.


If this is true, IsPropertyPath() will also be true.



"""
   result["Path"].IsTargetPath.func_doc = """IsTargetPath() -> bool


Returns whether the path identifies a relationship or connection
target.



"""
   result["Path"].IsMapperPath.func_doc = """IsMapperPath() -> bool


Returns whether the path identifies a connection mapper.



"""
   result["Path"].IsMapperArgPath.func_doc = """IsMapperArgPath() -> bool


Returns whether the path identifies a connection mapper arg.



"""
   result["Path"].IsExpressionPath.func_doc = """IsExpressionPath() -> bool


Returns whether the path identifies a connection expression.



"""
   result["Path"].GetAncestorsRange.func_doc = """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).



"""
   result["Path"].ReplaceName.func_doc = """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:

ReplaceName('/chars/MeridaGroup','AngusGroup')
\\->'/chars/AngusGroup'ReplaceName('/Merida.tx','ty')
\\->'/Merida.ty'ReplaceName('/Merida.tx[targ].tx','ty')
\\->'/Merida.tx[targ].ty'


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


"""
   result["Path"].GetAllTargetPathsRecursively.func_doc = """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]


"""
   result["Path"].GetVariantSelection.func_doc = """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.



"""
   result["Path"].HasPrefix.func_doc = """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


"""
   result["Path"].GetParentPath.func_doc = """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() .



"""
   result["Path"].GetPrimPath.func_doc = """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.



"""
   result["Path"].GetPrimOrPrimVariantSelectionPath.func_doc = """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.



"""
   result["Path"].GetAbsoluteRootOrPrimPath.func_doc = """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.



"""
   result["Path"].StripAllVariantSelections.func_doc = """StripAllVariantSelections() -> Path


Create a path by stripping all variant selections from all components
of this path, leaving a path with no embedded variant selections.



"""
   result["Path"].AppendPath.func_doc = """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


"""
   result["Path"].AppendChild.func_doc = """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


"""
   result["Path"].AppendProperty.func_doc = """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


"""
   result["Path"].AppendVariantSelection.func_doc = """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


"""
   result["Path"].AppendTarget.func_doc = """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


"""
   result["Path"].AppendRelationalAttribute.func_doc = """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


"""
   result["Path"].ReplaceTargetPath.func_doc = """ReplaceTargetPath(newTargetPath) -> Path


Replaces the relational attribute's target path.


The path must be a relational attribute path.


Parameters
----------
newTargetPath : Path


"""
   result["Path"].AppendMapper.func_doc = """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


"""
   result["Path"].AppendMapperArg.func_doc = """AppendMapperArg(argName) -> Path


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


This path must be a mapper path.


Parameters
----------
argName : str


"""
   result["Path"].AppendExpression.func_doc = """AppendExpression() -> Path


Creates a path by appending an expression element.


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



"""
   result["Path"].AppendElementString.func_doc = """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


"""
   result["Path"].ReplacePrefix.func_doc = """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


"""
   result["Path"].GetCommonPrefix.func_doc = """GetCommonPrefix(path) -> Path


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


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


"""
   result["Path"].RemoveCommonSuffix.func_doc = """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


"""
   result["Path"].MakeAbsolutePath.func_doc = """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


"""
   result["Path"].MakeRelativePath.func_doc = """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


"""
   result["Path"].IsValidIdentifier.func_doc = """**classmethod** IsValidIdentifier(name) -> bool


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


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


"""
   result["Path"].IsValidNamespacedIdentifier.func_doc = """**classmethod** IsValidNamespacedIdentifier(name) -> bool


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


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


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


"""
   result["Path"].TokenizeIdentifier.func_doc = """**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


"""
   result["Path"].JoinIdentifier.func_doc = """**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]



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

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[TfToken]



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

JoinIdentifier(lhs, 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



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

JoinIdentifier(lhs, 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


"""
   result["Path"].StripNamespace.func_doc = """**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



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

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


"""
   result["Path"].StripPrefixNamespace.func_doc = """**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


"""
   result["Path"].IsValidPathString.func_doc = """**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


"""
   result["Path"].GetConciseRelativePaths.func_doc = """**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]


"""
   result["Path"].RemoveDescendentPaths.func_doc = """**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]


"""
   result["Path"].RemoveAncestorPaths.func_doc = """**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]


"""
   result["Payload"].__doc__ = """
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.

"""
   result["Payload"].__init__.func_doc = """__init__(assetPath, primPath, layerOffset)


Create a payload.


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.


Parameters
----------
assetPath : str

primPath : Path

layerOffset : LayerOffset


"""
   result["PrimSpec"].__doc__ = """
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


"""
   result["PrimSpec"].CanSetName.func_doc = """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


"""
   result["PrimSpec"].ApplyNameChildrenOrder.func_doc = """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]


"""
   result["PrimSpec"].RemoveProperty.func_doc = """RemoveProperty(property) -> None


Removes the property.


Parameters
----------
property : PropertySpec


"""
   result["PrimSpec"].ApplyPropertyOrder.func_doc = """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]


"""
   result["PrimSpec"].GetPrimAtPath.func_doc = """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


"""
   result["PrimSpec"].GetPropertyAtPath.func_doc = """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


"""
   result["PrimSpec"].GetAttributeAtPath.func_doc = """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


"""
   result["PrimSpec"].GetRelationshipAtPath.func_doc = """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


"""
   result["PrimSpec"].HasActive.func_doc = """HasActive() -> bool


Returns true if this prim spec has an opinion about active.



"""
   result["PrimSpec"].ClearActive.func_doc = """ClearActive() -> None


Removes the active opinion in this prim spec if there is one.



"""
   result["PrimSpec"].HasKind.func_doc = """HasKind() -> bool


Returns true if this prim spec has an opinion about kind.



"""
   result["PrimSpec"].ClearKind.func_doc = """ClearKind() -> None


Remove the kind opinion from this prim spec if there is one.



"""
   result["PrimSpec"].HasInstanceable.func_doc = """HasInstanceable() -> bool


Returns true if this prim spec has a value authored for its
instanceable flag, false otherwise.



"""
   result["PrimSpec"].ClearInstanceable.func_doc = """ClearInstanceable() -> None


Clears the value for the prim's instanceable flag.



"""
   result["PrimSpec"].GetVariantNames.func_doc = """GetVariantNames(name) -> list[str]


Returns list of variant names for the given variant set.


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


"""
   result["PrimSpec"].BlockVariantSelection.func_doc = """BlockVariantSelection(variantSetName) -> None


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


Parameters
----------
variantSetName : str


"""
   result["PropertySpec"].__doc__ = """
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.

"""
   result["PropertySpec"].HasDefaultValue.func_doc = """HasDefaultValue() -> bool


Returns true if a default value is set for this attribute.



"""
   result["PropertySpec"].ClearDefaultValue.func_doc = """ClearDefaultValue() -> None


Clear the attribute's default value.



"""
   result["PseudoRootSpec"].__doc__ = """"""
   result["Reference"].__doc__ = """
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.

"""
   result["Reference"].__init__.func_doc = """__init__(assetPath, primPath, layerOffset, customData)


Creates a reference with all its meta data.


The default reference is an internal reference to the default prim.
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.


Parameters
----------
assetPath : str

primPath : Path

layerOffset : LayerOffset

customData : VtDictionary


"""
   result["Reference"].IsInternal.func_doc = """IsInternal() -> bool


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


An internal reference is a reference with an empty asset path.



"""
   result["RelationshipSpec"].__doc__ = """
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.

"""
   result["RelationshipSpec"].ReplaceTargetPath.func_doc = """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


"""
   result["RelationshipSpec"].RemoveTargetPath.func_doc = """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


"""
   result["Spec"].__doc__ = """
Base class for all Sdf spec classes.

"""
   result["Spec"].ListInfoKeys.func_doc = """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.



"""
   result["Spec"].GetMetaDataInfoKeys.func_doc = """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.



"""
   result["Spec"].GetMetaDataDisplayGroup.func_doc = """GetMetaDataDisplayGroup(key) -> str


Returns this metadata key's displayGroup.


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


"""
   result["Spec"].GetInfo.func_doc = """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


"""
   result["Spec"].SetInfo.func_doc = """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


"""
   result["Spec"].SetInfoDictionaryValue.func_doc = """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


"""
   result["TimeCode"].__doc__ = """
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.

"""
   result["TimeCode"].__init__.func_doc = """__init__(time)


Construct a time code with the given time.


A default constructed SdfTimeCode has a time of 0.0. A double value
can implicitly cast to SdfTimeCode.


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


"""
   result["TimeCode"].GetValue.func_doc = """GetValue() -> float


Return the time value.



"""
   result["UnregisteredValue"].__doc__ = """
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.

"""
   result["UnregisteredValue"].__init__.func_doc = """__init__()


Wraps an empty VtValue.




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

__init__(value)


Wraps a std::string.


Parameters
----------
value : str



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

__init__(value)


Wraps a VtDictionary.


Parameters
----------
value : VtDictionary



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

__init__(value)


Wraps a SdfUnregisteredValueListOp.


Parameters
----------
value : UnregisteredValueListOp


"""
   result["ValueBlock"].__doc__ = """
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()));


"""
   result["ValueTypeName"].__doc__ = """
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.

"""
   result["ValueTypeName"].__init__.func_doc = """__init__()


Constructs an invalid type name.




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

__init__(arg1)


Parameters
----------
arg1 : Sdf_ValueTypeImpl


"""
   result["VariantSetSpec"].__doc__ = """
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.

"""
   result["VariantSetSpec"].RemoveVariant.func_doc = """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


"""
   result["VariantSpec"].__doc__ = """
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.

"""
   result["VariantSpec"].GetVariantNames.func_doc = """GetVariantNames(name) -> list[str]


Returns list of variant names for the given variant set.


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


"""
   result["AssetPath"].resolvedPath = property(result["AssetPath"].resolvedPath.fget, result["AssetPath"].resolvedPath.fset, result["AssetPath"].resolvedPath.fdel, """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.

""")
   result["BatchNamespaceEdit"].edits = property(result["BatchNamespaceEdit"].edits.fget, result["BatchNamespaceEdit"].edits.fset, result["BatchNamespaceEdit"].edits.fdel, """type : list[SdfNamespaceEdit]


Returns the edits.

""")
   result["FileFormat"].formatId = property(result["FileFormat"].formatId.fget, result["FileFormat"].formatId.fset, result["FileFormat"].formatId.fdel, """type : str


Returns the format identifier.

""")
   result["FileFormat"].target = property(result["FileFormat"].target.fget, result["FileFormat"].target.fset, result["FileFormat"].target.fdel, """type : str


Returns the target for this file format.

""")
   result["FileFormat"].fileCookie = property(result["FileFormat"].fileCookie.fget, result["FileFormat"].fileCookie.fset, result["FileFormat"].fileCookie.fdel, """type : str


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

""")
   result["FileFormat"].primaryFileExtension = property(result["FileFormat"].primaryFileExtension.fget, result["FileFormat"].primaryFileExtension.fset, result["FileFormat"].primaryFileExtension.fdel, """type : str


Returns the primary file extension for this format.


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

""")
   result["Layer"].empty = property(result["Layer"].empty.fget, result["Layer"].empty.fset, result["Layer"].empty.fdel, """type : bool


Returns whether this layer has no significant data.

""")
   result["Layer"].anonymous = property(result["Layer"].anonymous.fget, result["Layer"].anonymous.fset, result["Layer"].anonymous.fdel, """type : bool


Returns true if this layer is an anonymous layer.

""")
   result["Layer"].dirty = property(result["Layer"].dirty.fget, result["Layer"].dirty.fset, result["Layer"].dirty.fdel, """type : bool


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


has changed from its persistent representation.

""")
   result["LayerOffset"].offset = property(result["LayerOffset"].offset.fget, result["LayerOffset"].offset.fset, result["LayerOffset"].offset.fdel, """type : None


Sets the time offset.

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

type : float


Returns the time offset.

""")
   result["LayerOffset"].scale = property(result["LayerOffset"].scale.fget, result["LayerOffset"].scale.fset, result["LayerOffset"].scale.fdel, """type : None


Sets the time scale factor.

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

type : float


Returns the time scale factor.

""")
   result["LayerTree"].layer = property(result["LayerTree"].layer.fget, result["LayerTree"].layer.fset, result["LayerTree"].layer.fdel, """type : Layer


Returns the layer handle this tree node represents.

""")
   result["LayerTree"].offset = property(result["LayerTree"].offset.fget, result["LayerTree"].offset.fset, result["LayerTree"].offset.fdel, """type : LayerOffset


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

""")
   result["LayerTree"].childTrees = property(result["LayerTree"].childTrees.fget, result["LayerTree"].childTrees.fset, result["LayerTree"].childTrees.fdel, """type : list[SdfLayerTreeHandle]


Returns the children of this tree node.

""")
   result["Path"].isEmpty = property(result["Path"].isEmpty.fget, result["Path"].isEmpty.fset, result["Path"].isEmpty.fdel, """type : bool


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

""")
   result["Payload"].assetPath = property(result["Payload"].assetPath.fget, result["Payload"].assetPath.fset, result["Payload"].assetPath.fdel, """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.

""")
   result["Payload"].primPath = property(result["Payload"].primPath.fget, result["Payload"].primPath.fset, result["Payload"].primPath.fdel, """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.

""")
   result["Payload"].layerOffset = property(result["Payload"].layerOffset.fget, result["Payload"].layerOffset.fset, result["Payload"].layerOffset.fdel, """type : None


Sets a new layer offset.

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

type : LayerOffset


Returns the layer offset associated with the payload.

""")
   result["Reference"].assetPath = property(result["Reference"].assetPath.fget, result["Reference"].assetPath.fset, result["Reference"].assetPath.fdel, """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.

""")
   result["Reference"].primPath = property(result["Reference"].primPath.fget, result["Reference"].primPath.fset, result["Reference"].primPath.fdel, """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.

""")
   result["Reference"].layerOffset = property(result["Reference"].layerOffset.fget, result["Reference"].layerOffset.fset, result["Reference"].layerOffset.fdel, """type : None


Sets a new layer offset.

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

type : LayerOffset


Returns the layer offset associated with the reference.

""")
   result["Reference"].customData = property(result["Reference"].customData.fget, result["Reference"].customData.fset, result["Reference"].customData.fdel, """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.

""")
   result["UnregisteredValue"].value = property(result["UnregisteredValue"].value.fget, result["UnregisteredValue"].value.fset, result["UnregisteredValue"].value.fdel, """type : VtValue


Returns the wrapped VtValue specified in the constructor.

""")
   result["ValueTypeName"].type = property(result["ValueTypeName"].type.fget, result["ValueTypeName"].type.fset, result["ValueTypeName"].type.fdel, """type : Type


Returns the ``TfType`` of the type.

""")
   result["ValueTypeName"].role = property(result["ValueTypeName"].role.fget, result["ValueTypeName"].role.fset, result["ValueTypeName"].role.fdel, """type : str


Returns the type's role.

""")
   result["ValueTypeName"].defaultValue = property(result["ValueTypeName"].defaultValue.fget, result["ValueTypeName"].defaultValue.fset, result["ValueTypeName"].defaultValue.fdel, """type : VtValue


Returns the default value for the type.

""")
   result["ValueTypeName"].defaultUnit = property(result["ValueTypeName"].defaultUnit.fget, result["ValueTypeName"].defaultUnit.fset, result["ValueTypeName"].defaultUnit.fdel, """type : Enum


Returns the default unit enum for the type.

""")
   result["ValueTypeName"].scalarType = property(result["ValueTypeName"].scalarType.fget, result["ValueTypeName"].scalarType.fset, result["ValueTypeName"].scalarType.fdel, """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.

""")
   result["ValueTypeName"].arrayType = property(result["ValueTypeName"].arrayType.fget, result["ValueTypeName"].arrayType.fset, result["ValueTypeName"].arrayType.fdel, """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.

""")
   result["ValueTypeName"].isScalar = property(result["ValueTypeName"].isScalar.fget, result["ValueTypeName"].isScalar.fset, result["ValueTypeName"].isScalar.fdel, """type : bool


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


The invalid type is considered neither scalar nor array.

""")
   result["ValueTypeName"].isArray = property(result["ValueTypeName"].isArray.fget, result["ValueTypeName"].isArray.fset, result["ValueTypeName"].isArray.fdel, """type : bool


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


The invalid type is considered neither scalar nor array.

""")
   result["VariantSpec"].variantSets = property(result["VariantSpec"].variantSets.fget, result["VariantSpec"].variantSets.fset, result["VariantSpec"].variantSets.fdel, """type : SdfVariantSetsProxy


Returns the nested variant sets.


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

""")