from __future__ import annotations
import pxr.Sdr._sdr
import typing
import Boost.Python
import pxr.Ndr

__all__ = [
    "NodeContext",
    "NodeMetadata",
    "NodeRole",
    "PropertyMetadata",
    "PropertyRole",
    "PropertyTypes",
    "Registry",
    "ShaderNode",
    "ShaderNodeList",
    "ShaderProperty"
]


class NodeContext(Boost.Python.instance):
    Displacement = 'displacement'
    Light = 'light'
    LightFilter = 'lightFilter'
    Pattern = 'pattern'
    PixelFilter = 'pixelFilter'
    SampleFilter = 'sampleFilter'
    Surface = 'surface'
    Volume = 'volume'
    pass
class NodeMetadata(Boost.Python.instance):
    Category = 'category'
    Departments = 'departments'
    Help = 'help'
    ImplementationName = '__SDR__implementationName'
    Label = 'label'
    Pages = 'pages'
    Primvars = 'primvars'
    Role = 'role'
    SdrDefinitionNameFallbackPrefix = 'sdrDefinitionNameFallbackPrefix'
    SdrUsdEncodingVersion = 'sdrUsdEncodingVersion'
    Target = '__SDR__target'
    pass
class NodeRole(Boost.Python.instance):
    Field = 'field'
    Math = 'math'
    Primvar = 'primvar'
    Texture = 'texture'
    pass
class PropertyMetadata(Boost.Python.instance):
    Colorspace = '__SDR__colorspace'
    Connectable = 'connectable'
    DefaultInput = '__SDR__defaultinput'
    Help = 'help'
    Hints = 'hints'
    ImplementationName = '__SDR__implementationName'
    IsAssetIdentifier = '__SDR__isAssetIdentifier'
    IsDynamicArray = 'isDynamicArray'
    Label = 'label'
    Options = 'options'
    Page = 'page'
    RenderType = 'renderType'
    Role = 'role'
    SdrUsdDefinitionType = 'sdrUsdDefinitionType'
    Target = '__SDR__target'
    ValidConnectionTypes = 'validConnectionTypes'
    VstructConditionalExpr = 'vstructConditionalExpr'
    VstructMemberName = 'vstructMemberName'
    VstructMemberOf = 'vstructMemberOf'
    Widget = 'widget'
    pass
class PropertyRole(Boost.Python.instance):
    None = 'none'
    pass
class PropertyTypes(Boost.Python.instance):
    Color = 'color'
    Color4 = 'color4'
    Float = 'float'
    Int = 'int'
    Matrix = 'matrix'
    Normal = 'normal'
    Point = 'point'
    String = 'string'
    Struct = 'struct'
    Terminal = 'terminal'
    Unknown = 'unknown'
    Vector = 'vector'
    Vstruct = 'vstruct'
    pass
class Registry(Boost.Python.instance):
    """
    The shading-specialized version of ``NdrRegistry`` .
    """
    @staticmethod
    def GetShaderNodeByIdentifier(identifier, typePriority) -> ShaderNode: 
        """
        GetShaderNodeByIdentifier(identifier, typePriority) -> ShaderNode


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


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

        typePriority : NdrTokenVec
        """
    @staticmethod
    def GetShaderNodeByIdentifierAndType(identifier, nodeType) -> ShaderNode: 
        """
        GetShaderNodeByIdentifierAndType(identifier, nodeType) -> ShaderNode


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


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

        nodeType : str
        """
    @staticmethod
    def GetShaderNodeByName(name, typePriority, filter) -> ShaderNode: 
        """
        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
        """
    @staticmethod
    def GetShaderNodeByNameAndType(name, nodeType, filter) -> ShaderNode: 
        """
        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
        """
    @staticmethod
    def GetShaderNodeFromAsset(shaderAsset, metadata, subIdentifier, sourceType) -> ShaderNode: 
        """
        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
        """
    @staticmethod
    def GetShaderNodeFromSourceCode(sourceCode, sourceType, metadata) -> ShaderNode: 
        """
        GetShaderNodeFromSourceCode(sourceCode, sourceType, metadata) -> ShaderNode


        Wrapper method for NdrRegistry::GetNodeFromSourceCode() .


        Returns a valid SdrShaderNode pointer upon success.


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

        sourceType : str

        metadata : NdrTokenMap
        """
    @staticmethod
    def GetShaderNodesByFamily(family, filter) -> SdrShaderNodePtrVec: 
        """
        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
        """
    @staticmethod
    def GetShaderNodesByIdentifier(identifier) -> SdrShaderNodePtrVec: 
        """
        GetShaderNodesByIdentifier(identifier) -> SdrShaderNodePtrVec


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


        Parameters
        ----------
        identifier : NdrIdentifier
        """
    @staticmethod
    def GetShaderNodesByName(name, filter) -> SdrShaderNodePtrVec: 
        """
        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
        """
    @property
    def expired(self) -> None:
        """
        True if this object has expired, False otherwise.

        :type: None
        """
    pass
class ShaderNode(pxr.Ndr.Node, Boost.Python.instance):
    """
    A specialized version of ``NdrNode`` which holds shading information.
    """
    @staticmethod
    def GetAdditionalPrimvarProperties() -> NdrTokenVec: 
        """
        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.
        """
    @staticmethod
    def GetAllVstructNames() -> NdrTokenVec: 
        """
        GetAllVstructNames() -> NdrTokenVec


        Gets all vstructs that are present in the shader.
        """
    @staticmethod
    def GetAssetIdentifierInputNames() -> NdrTokenVec: 
        """
        GetAssetIdentifierInputNames() -> NdrTokenVec


        Returns the list of all inputs that are tagged as asset identifier
        inputs.
        """
    @staticmethod
    def GetCategory() -> str: 
        """
        GetCategory() -> str


        The category assigned to this node, if any.


        Distinct from the family returned from ``GetFamily()`` .
        """
    @staticmethod
    def GetDefaultInput() -> ShaderProperty: 
        """
        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.
        """
    @staticmethod
    def GetDepartments() -> NdrTokenVec: 
        """
        GetDepartments() -> NdrTokenVec


        The departments this node is associated with, if any.
        """
    @staticmethod
    def GetHelp() -> str: 
        """
        GetHelp() -> str


        The help message assigned to this node, if any.
        """
    @staticmethod
    def GetImplementationName() -> str: 
        """
        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.
        """
    @staticmethod
    def GetLabel() -> str: 
        """
        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.
        """
    @staticmethod
    def GetPages() -> NdrTokenVec: 
        """
        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'.
        """
    @staticmethod
    def GetPrimvars() -> NdrTokenVec: 
        """
        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.
        """
    @staticmethod
    def GetPropertyNamesForPage(pageName) -> NdrTokenVec: 
        """
        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
        """
    @staticmethod
    def GetRole() -> str: 
        """
        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.
        """
    @staticmethod
    def GetShaderInput(inputName) -> ShaderProperty: 
        """
        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
        """
    @staticmethod
    def GetShaderOutput(outputName) -> ShaderProperty: 
        """
        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
        """
    pass
class ShaderNodeList(Boost.Python.instance):
    @staticmethod
    def append(*args, **kwargs) -> None: ...
    @staticmethod
    def extend(*args, **kwargs) -> None: ...
    __instance_size__ = 40
    pass
class ShaderProperty(pxr.Ndr.Property, Boost.Python.instance):
    """
    A specialized version of ``NdrProperty`` which holds shading
    information.
    """
    @staticmethod
    def GetDefaultValueAsSdfType() -> VtValue: 
        """
        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
        """
    @staticmethod
    def GetHelp() -> str: 
        """
        GetHelp() -> str


        The help message assigned to this property, if any.
        """
    @staticmethod
    def GetHints() -> NdrTokenMap: 
        """
        GetHints() -> NdrTokenMap


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


        "Hints"are simple key/value pairs.
        """
    @staticmethod
    def GetImplementationName() -> str: 
        """
        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.
        """
    @staticmethod
    def GetLabel() -> str: 
        """
        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.
        """
    @staticmethod
    def GetOptions() -> NdrOptionVec: 
        """
        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).
        """
    @staticmethod
    def GetPage() -> str: 
        """
        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.
        """
    @staticmethod
    def GetVStructConditionalExpr() -> str: 
        """
        GetVStructConditionalExpr() -> str


        If this field is part of a vstruct, this is the conditional
        expression.
        """
    @staticmethod
    def GetVStructMemberName() -> str: 
        """
        GetVStructMemberName() -> str


        If this field is part of a vstruct, this is its name in the struct.
        """
    @staticmethod
    def GetVStructMemberOf() -> str: 
        """
        GetVStructMemberOf() -> str


        If this field is part of a vstruct, this is the name of the struct.
        """
    @staticmethod
    def GetValidConnectionTypes() -> NdrTokenVec: 
        """
        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()`` .
        """
    @staticmethod
    def GetWidget() -> str: 
        """
        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.
        """
    @staticmethod
    def IsAssetIdentifier() -> bool: 
        """
        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).
        """
    @staticmethod
    def IsDefaultInput() -> bool: 
        """
        IsDefaultInput() -> bool


        Determines if the value held by this property is the default input for
        this node.
        """
    @staticmethod
    def IsVStruct() -> bool: 
        """
        IsVStruct() -> bool


        Returns true if the field is the head of a vstruct.
        """
    @staticmethod
    def IsVStructMember() -> bool: 
        """
        IsVStructMember() -> bool


        Returns true if this field is part of a vstruct.
        """
    pass
__MFB_FULL_PACKAGE_NAME = 'sdr'
