def Execute(result):
   result["Registry"].__doc__ = """
The shading-specialized version of ``NdrRegistry`` .

"""
   result["Registry"].GetShaderNodeByIdentifier.func_doc = """GetShaderNodeByIdentifier(identifier, typePriority) -> ShaderNode


Exactly like ``NdrRegistry::GetNodeByIdentifier()`` , but returns a
``SdrShaderNode`` pointer instead of a ``NdrNode`` pointer.


Parameters
----------
identifier : NdrIdentifier

typePriority : NdrTokenVec


"""
   result["Registry"].GetShaderNodeByIdentifierAndType.func_doc = """GetShaderNodeByIdentifierAndType(identifier, nodeType) -> ShaderNode


Exactly like ``NdrRegistry::GetNodeByIdentifierAndType()`` , but
returns a ``SdrShaderNode`` pointer instead of a ``NdrNode`` pointer.


Parameters
----------
identifier : NdrIdentifier

nodeType : str


"""
   result["Registry"].GetShaderNodeByName.func_doc = """GetShaderNodeByName(name, typePriority, filter) -> ShaderNode


Exactly like ``NdrRegistry::GetNodeByName()`` , but returns a
``SdrShaderNode`` pointer instead of a ``NdrNode`` pointer.


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

typePriority : NdrTokenVec

filter : VersionFilter


"""
   result["Registry"].GetShaderNodeByNameAndType.func_doc = """GetShaderNodeByNameAndType(name, nodeType, filter) -> ShaderNode


Exactly like ``NdrRegistry::GetNodeByNameAndType()`` , but returns a
``SdrShaderNode`` pointer instead of a ``NdrNode`` pointer.


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

nodeType : str

filter : VersionFilter


"""
   result["Registry"].GetShaderNodeFromAsset.func_doc = """GetShaderNodeFromAsset(shaderAsset, metadata, subIdentifier, sourceType) -> ShaderNode


Wrapper method for NdrRegistry::GetNodeFromAsset() .


Returns a valid SdrShaderNode pointer upon success.


Parameters
----------
shaderAsset : AssetPath

metadata : NdrTokenMap

subIdentifier : str

sourceType : str


"""
   result["Registry"].GetShaderNodeFromSourceCode.func_doc = """GetShaderNodeFromSourceCode(sourceCode, sourceType, metadata) -> ShaderNode


Wrapper method for NdrRegistry::GetNodeFromSourceCode() .


Returns a valid SdrShaderNode pointer upon success.


Parameters
----------
sourceCode : str

sourceType : str

metadata : NdrTokenMap


"""
   result["Registry"].GetShaderNodesByIdentifier.func_doc = """GetShaderNodesByIdentifier(identifier) -> SdrShaderNodePtrVec


Exactly like ``NdrRegistry::GetNodesByIdentifier()`` , but returns a
vector of ``SdrShaderNode`` pointers instead of a vector of
``NdrNode`` pointers.


Parameters
----------
identifier : NdrIdentifier


"""
   result["Registry"].GetShaderNodesByName.func_doc = """GetShaderNodesByName(name, filter) -> SdrShaderNodePtrVec


Exactly like ``NdrRegistry::GetNodesByName()`` , but returns a vector
of ``SdrShaderNode`` pointers instead of a vector of ``NdrNode``
pointers.


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

filter : VersionFilter


"""
   result["Registry"].GetShaderNodesByFamily.func_doc = """GetShaderNodesByFamily(family, filter) -> SdrShaderNodePtrVec


Exactly like ``NdrRegistry::GetNodesByFamily()`` , but returns a
vector of ``SdrShaderNode`` pointers instead of a vector of
``NdrNode`` pointers.


Parameters
----------
family : str

filter : VersionFilter


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



"""
   result["ShaderNode"].__doc__ = """
A specialized version of ``NdrNode`` which holds shading information.

"""
   result["ShaderNode"].GetShaderInput.func_doc = """GetShaderInput(inputName) -> ShaderProperty


Get a shader input property by name.


``nullptr`` is returned if an input with the given name does not
exist.


Parameters
----------
inputName : str


"""
   result["ShaderNode"].GetShaderOutput.func_doc = """GetShaderOutput(outputName) -> ShaderProperty


Get a shader output property by name.


``nullptr`` is returned if an output with the given name does not
exist.


Parameters
----------
outputName : str


"""
   result["ShaderNode"].GetAssetIdentifierInputNames.func_doc = """GetAssetIdentifierInputNames() -> NdrTokenVec


Returns the list of all inputs that are tagged as asset identifier
inputs.



"""
   result["ShaderNode"].GetDefaultInput.func_doc = """GetDefaultInput() -> ShaderProperty


Returns the first shader input that is tagged as the default input.


A default input and its value can be used to acquire a fallback value
for a node when the node is considered'disabled'or otherwise incapable
of producing an output value.



"""
   result["ShaderNode"].GetLabel.func_doc = """GetLabel() -> str


The label assigned to this node, if any.


Distinct from the name returned from ``GetName()`` . In the context of
a UI, the label value might be used as the display name for the node
instead of the name.



"""
   result["ShaderNode"].GetCategory.func_doc = """GetCategory() -> str


The category assigned to this node, if any.


Distinct from the family returned from ``GetFamily()`` .



"""
   result["ShaderNode"].GetRole.func_doc = """GetRole() -> str


Returns the role of this node.


This is used to annotate the role that the shader node plays inside a
shader network. We can tag certain shaders to indicate their role
within a shading network. We currently tag primvar reading nodes,
texture reading nodes and nodes that access volume fields (like
extinction or scattering). This is done to identify resources used by
a shading network.



"""
   result["ShaderNode"].GetHelp.func_doc = """GetHelp() -> str


The help message assigned to this node, if any.



"""
   result["ShaderNode"].GetDepartments.func_doc = """GetDepartments() -> NdrTokenVec


The departments this node is associated with, if any.



"""
   result["ShaderNode"].GetPages.func_doc = """GetPages() -> NdrTokenVec


Gets the pages on which the node's properties reside (an aggregate of
the unique ``SdrShaderProperty::GetPage()`` values for all of the
node's properties).


Nodes themselves do not reside on pages. In an example scenario,
properties might be divided into two pages,'Simple'and'Advanced'.



"""
   result["ShaderNode"].GetPrimvars.func_doc = """GetPrimvars() -> NdrTokenVec


The list of primvars this node knows it requires / uses.


For example, a shader node may require the'normals'primvar to function
correctly. Additional, user specified primvars may have been authored
on the node. These can be queried via
``GetAdditionalPrimvarProperties()`` . Together, ``GetPrimvars()`` and
``GetAdditionalPrimvarProperties()`` , provide the complete list of
primvar requirements for the node.



"""
   result["ShaderNode"].GetAdditionalPrimvarProperties.func_doc = """GetAdditionalPrimvarProperties() -> NdrTokenVec


The list of string input properties whose values provide the names of
additional primvars consumed by this node.


For example, this may return a token named ``varname`` . This
indicates that the client should query the value of a (presumed to be
string-valued) input attribute named varname from its scene
description to determine the name of a primvar the node will consume.
See ``GetPrimvars()`` for additional information.



"""
   result["ShaderNode"].GetImplementationName.func_doc = """GetImplementationName() -> str


Returns the implementation name of this node.


The name of the node is how to refer to the node in shader networks.
The label is how to present this node to users. The implementation
name is the name of the function (or something) this node represents
in the implementation. Any client using the implementation **must**
call this method to get the correct name; using ``getName()`` is not
correct.



"""
   result["ShaderNode"].GetPropertyNamesForPage.func_doc = """GetPropertyNamesForPage(pageName) -> NdrTokenVec


Gets the names of the properties on a certain page (one that was
returned by ``GetPages()`` ).


To get properties that are not assigned to a page, an empty string can
be used for ``pageName`` .


Parameters
----------
pageName : str


"""
   result["ShaderNode"].GetAllVstructNames.func_doc = """GetAllVstructNames() -> NdrTokenVec


Gets all vstructs that are present in the shader.



"""
   result["ShaderProperty"].__doc__ = """
A specialized version of ``NdrProperty`` which holds shading
information.

"""
   result["ShaderProperty"].GetLabel.func_doc = """GetLabel() -> str


The label assigned to this property, if any.


Distinct from the name returned from ``GetName()`` . In the context of
a UI, the label value might be used as the display name for the
property instead of the name.



"""
   result["ShaderProperty"].GetHelp.func_doc = """GetHelp() -> str


The help message assigned to this property, if any.



"""
   result["ShaderProperty"].GetPage.func_doc = """GetPage() -> str


The page (group), eg"Advanced", this property appears on, if any.


Note that the page for a shader property can be nested, delimited
by":", representing the hierarchy of sub-pages a property is defined
in.



"""
   result["ShaderProperty"].GetWidget.func_doc = """GetWidget() -> str


The widget"hint"that indicates the widget that can best display the
type of data contained in this property, if any.


Examples of this value could include"number","slider", etc.



"""
   result["ShaderProperty"].GetHints.func_doc = """GetHints() -> NdrTokenMap


Any UI"hints"that are associated with this property.


"Hints"are simple key/value pairs.



"""
   result["ShaderProperty"].GetOptions.func_doc = """GetOptions() -> NdrOptionVec


If the property has a set of valid values that are pre-determined,
this will return the valid option names and corresponding string
values (if the option was specified with a value).



"""
   result["ShaderProperty"].GetImplementationName.func_doc = """GetImplementationName() -> str


Returns the implementation name of this property.


The name of the property is how to refer to the property in shader
networks. The label is how to present this property to users. The
implementation name is the name of the parameter this property
represents in the implementation. Any client using the implementation
**must** call this method to get the correct name; using ``getName()``
is not correct.



"""
   result["ShaderProperty"].GetVStructMemberOf.func_doc = """GetVStructMemberOf() -> str


If this field is part of a vstruct, this is the name of the struct.



"""
   result["ShaderProperty"].GetVStructMemberName.func_doc = """GetVStructMemberName() -> str


If this field is part of a vstruct, this is its name in the struct.



"""
   result["ShaderProperty"].IsVStructMember.func_doc = """IsVStructMember() -> bool


Returns true if this field is part of a vstruct.



"""
   result["ShaderProperty"].IsVStruct.func_doc = """IsVStruct() -> bool


Returns true if the field is the head of a vstruct.



"""
   result["ShaderProperty"].GetVStructConditionalExpr.func_doc = """GetVStructConditionalExpr() -> str


If this field is part of a vstruct, this is the conditional
expression.



"""
   result["ShaderProperty"].IsConnectable.func_doc = """IsConnectable() -> bool


Whether this property can be connected to other properties.


If this returns ``true`` , connectability to a specific property can
be tested via ``CanConnectTo()`` .



"""
   result["ShaderProperty"].GetValidConnectionTypes.func_doc = """GetValidConnectionTypes() -> NdrTokenVec


Gets the list of valid connection types for this property.


This value comes from shader metadata, and may not be specified. The
value from ``NdrProperty::GetType()`` can be used as a fallback, or
you can use the connectability test in ``CanConnectTo()`` .



"""
   result["ShaderProperty"].CanConnectTo.func_doc = """CanConnectTo(other) -> bool


Determines if this property can be connected to the specified
property.


Parameters
----------
other : Property


"""
   result["ShaderProperty"].GetTypeAsSdfType.func_doc = """GetTypeAsSdfType() -> NdrSdfTypeIndicator


Converts the property's type from ``GetType()`` into a
``SdfValueTypeName`` .


Two scenarios can result: an exact mapping from property type to Sdf
type, and an inexact mapping. In the first scenario, the first element
in the pair will be the cleanly-mapped Sdf type, and the second
element, a TfToken, will be empty. In the second scenario, the Sdf
type will be set to ``Token`` to indicate an unclean mapping, and the
second element will be set to the original type returned by
``GetType()`` .

GetDefaultValueAsSdfType



"""
   result["ShaderProperty"].GetDefaultValueAsSdfType.func_doc = """GetDefaultValueAsSdfType() -> VtValue


Accessor for default value corresponding to the SdfValueTypeName
returned by GetTypeAsSdfType.


Note that this is different than GetDefaultValue which returns the
default value associated with the SdrPropertyType and may differ from
the SdfValueTypeName, example when sdrUsdDefinitionType metadata is
specified for a sdr property.

GetTypeAsSdfType



"""
   result["ShaderProperty"].IsAssetIdentifier.func_doc = """IsAssetIdentifier() -> bool


Determines if the value held by this property is an asset identifier
(eg, a file path); the logic for this is left up to the parser.


Note: The type returned from ``GetTypeAsSdfType()`` will be ``Asset``
if this method returns ``true`` (even though its true underlying data
type is string).



"""
   result["ShaderProperty"].IsDefaultInput.func_doc = """IsDefaultInput() -> bool


Determines if the value held by this property is the default input for
this node.



"""