What's new in USDKit

extension Array where Element == String {

    /// Reorders elements in place to match `order`, preserving elements
    /// not in `order`. Implements USD's "ordered" list-op semantics.
    ///
    /// - Parameter order: The desired ordering for elements that appear
    ///   in both `self` and `order`.
    public mutating func applyListOrder(_ order: [String])
}

extension Array where Element == USDToken {

    /// Reorders elements in place to match `order`, preserving elements
    /// not in `order`. Implements USD's "ordered" list-op semantics.
    ///
    /// - Parameter order: The desired ordering for elements that appear
    ///   in both `self` and `order`.
    public mutating func applyListOrder(_ order: [USDToken])
}

extension Bool : USDValueProtocol {
}

extension Bool : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension Bool : USDPrim.Attribute.MetadataValue {
}

public struct DeformationData : Sendable {

    public let id: DeformationID

    public struct SkinningData : Sendable {

        public let influencePerVertexCount: UInt8

        public let jointTransforms: [float4x4]

        public let inverseBindPoses: [float4x4]

        public let influenceJointIndices: [UInt32]

        public let influenceWeights: [Float]

        public let geometryBindTransform: float4x4

        public struct Update : Sendable {

            public let jointTransforms: [float4x4]?

            public let inverseBindPoses: [float4x4]?

            public let influenceJointIndices: [UInt32]?

            public let influenceWeights: [Float]?

            public let geometryBindTransform: float4x4?
        }
    }

    public struct BlendShapeData : Sendable {

        public let weights: [Float]

        public let positionOffsets: [[SIMD3<Float>]]

        public struct Update : Sendable {

            public let weights: [Float]?

            public let positionOffsets: [[SIMD3<Float>]]?
        }
    }

    public struct RenormalizationData : Sendable {

        public let vertexIndicesPerTriangle: [UInt32]

        public let vertexAdjacencies: [UInt32]

        public let vertexAdjacencyEndIndices: [UInt32]

        public struct Update : Sendable {

            public let vertexIndicesPerTriangle: [UInt32]?

            public let vertexAdjacencies: [UInt32]?

            public let vertexAdjacencyEndIndices: [UInt32]?
        }
    }

    public let skinningData: DeformationData.SkinningData?

    public let blendShapeData: DeformationData.BlendShapeData?

    public let renormalizationData: DeformationData.RenormalizationData?

    public struct Update : Sendable {

        public let id: DeformationID

        public let skinningDataUpdate: DeformationData.SkinningData.Update?

        public let blendShapeDataUpdate: DeformationData.BlendShapeData.Update?

        public let renormalizationDataUpdate: DeformationData.RenormalizationData.Update?
    }

Truncated.

public struct DeformationID {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: DeformationID, b: DeformationID) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension DeformationID : CustomStringConvertible {
}

extension DeformationID : Sendable {
}

extension DeformationID : Hashable {
}

extension Dictionary where Key == String, Value == USDValue {

    /// Subscript that shadows the standard Dictionary subscript to provide
    /// path-based access. When the key contains `":"`, it is treated as a path
    /// with `":"` as the delimiter; otherwise the regular dictionary key
    /// semantics apply.
    public subscript(key: String) -> USDValue?

    /// Accesses the value at the given key path.
    ///
    /// Reads return `nil` if no value is present at the path. Assigning a
    /// non-`nil` value sets it at the path, creating intermediate dictionaries
    /// as needed; assigning `nil` erases the value at the path.
    public subscript(keyPath: [String]) -> USDValue?

    /// Accesses the value at the given delimited key path.
    ///
    /// Reads return `nil` if no value is present at the path. Assigning a
    /// non-`nil` value sets it at the path, creating intermediate dictionaries
    /// as needed; assigning `nil` erases the value at the path.
    ///
    /// - Parameters:
    ///   - keyPath: A string of components separated by characters in `delimiters`.
    ///   - delimiters: The characters that separate path components.
    public subscript(keyPath: String, delimiters: String) -> USDValue?
}

extension Double : USDValueProtocol {
}

extension Double : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension Double : USDPrim.Attribute.MetadataValue {
}

extension Float : USDValueProtocol {
}

extension Float : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension Float : USDPrim.Attribute.MetadataValue {
}

extension Int : USDValueProtocol {
}

extension Int : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension Int : USDPrim.Attribute.MetadataValue {
}

extension Int32 : USDValueProtocol {
}

extension Int32 : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension Int32 : USDPrim.Attribute.MetadataValue {
}

extension Int64 : USDValueProtocol {
}

extension Int64 : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension Int64 : USDPrim.Attribute.MetadataValue {
}

extension Int8 : USDValueProtocol {
}

public struct MaterialData : Sendable {

    public let id: MaterialID

    public let primPath: String

    public let assignedTextures: [String : TextureID]

    public var shaderGraph: ShaderGraph { get }

    public struct Update : Sendable {

        public let id: MaterialID

        public let assignedTextures: [String : TextureID]?
    }
}

public struct MaterialID {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: MaterialID, b: MaterialID) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension MaterialID : CustomStringConvertible {
}

extension MaterialID : Sendable {
}

extension MaterialID : Hashable {
}

public struct MeshData : Sendable {

    public let id: MeshID

    public let primPath: String

    public let descriptor: LowLevelMesh.Descriptor

    public let parts: [LowLevelMesh.Part]

    public let indexData: Data

    public let vertexData: [Data]

    public let instanceTransforms: [float4x4]

    public let assignedMaterials: [MaterialID]

    public let meshType: MeshData.MeshType

    public enum MeshType : Sendable {

        case `static`

        case deformable(DeformationID)
    }

    public struct Update : Sendable {

        public let id: MeshID

        public let parts: [LowLevelMesh.Part]?

        public let indexData: Data?

        public let vertexData: [Data]?

        public let instanceTransforms: [float4x4]?

        public let assignedMaterials: [MaterialID]?

        public let meshType: MeshData.MeshType?
    }
}

public struct MeshID {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: MeshID, b: MeshID) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension MeshID : CustomStringConvertible {
}

extension MeshID : Sendable {
}

extension MeshID : Hashable {
}

extension NSNotification.Name {

    public static let USDStageKitRenderComplete: Notification.Name
}

public protocol StageKitPlugin {

    static func register() -> Bool
}

extension StageKitPlugin {

    @discardableResult
    public static func register() -> Bool
}

extension String : USDValueProtocol {
}

extension String : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension String : USDPrim.Attribute.MetadataValue {
}

public struct TextureData : Sendable {

    public let id: TextureID

    public let assetPath: String

    public let descriptor: LowLevelTexture.Descriptor

    public let layout: [TextureLevelInfo]

    public let data: Data
}

public struct TextureID {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: TextureID, b: TextureID) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension TextureID : CustomStringConvertible {
}

extension TextureID : Sendable {
}

extension TextureID : Hashable {
}

public struct TextureLevelInfo : Sendable {

    public let dataOffset: Int

    public let byteCountPerRow: Int

    public let byteCountPerImage: Int
}

extension UInt : USDValueProtocol {
}

extension UInt : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension UInt : USDPrim.Attribute.MetadataValue {
}

extension UInt32 : USDValueProtocol {
}

extension UInt32 : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension UInt32 : USDPrim.Attribute.MetadataValue {
}

extension UInt64 : USDValueProtocol {
}

extension UInt64 : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension UInt64 : USDPrim.Attribute.MetadataValue {
}

extension UInt8 : USDValueProtocol {
}

extension UInt8 : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension UInt8 : USDPrim.Attribute.MetadataValue {
}

public struct USDLayer {

    /// Creates an anonymous, in-memory layer.
    ///
    /// Anonymous layers have no file backing.
    ///
    /// - Parameter displayName: A non-unique hint shown in debug output and logs.
    /// - Throws: An error if the layer cannot be created.
    public init(displayName: String? = nil) throws
}

extension USDLayer {

    /// A list of changes made to a layer.
    ///
    /// Used by the layer change notification system to describe what
    /// modifications occurred between two states of a layer.
    public struct ChangeList {

        /// All change entries, keyed by the path of the affected spec.
        public var entries: [(USDLayer.Path, USDLayer.ChangeList.Entry)] { get }

        /// A single change entry describing modifications at a path.
        public struct Entry {

            /// Info field changes, keyed by field name. Each `InfoChange`
            /// contains the old and new values.
            public var infoChanged: [(USDToken, USDLayer.ChangeList.Entry.InfoChange)] { get }

            /// Structural change flags for this entry.
            public var flags: USDLayer.ChangeList.Entry.Flags { get }

            /// Old and new values for a changed info field.
            public struct InfoChange {

                /// The value before the change, or `nil` if the field was added.
                public var oldValue: USDValue? { get }

                /// The value after the change, or `nil` if the field was removed.
                public var newValue: USDValue? { get }
            }

            /// Boolean flags describing structural changes to a spec.
            public struct Flags {

                /// Whether the layer's identifier changed.
                public var didChangeIdentifier: Bool { get }

                /// Whether the layer's resolved path changed.
                public var didChangeResolvedPath: Bool { get }

                /// Whether the layer's content was replaced.
                public var didReplaceContent: Bool { get }

                /// Whether the layer was reloaded from its source.
                public var didReloadContent: Bool { get }

                /// Whether the children list of a prim was reordered.
                public var didReorderChildren: Bool { get }

                /// Whether the properties list of a prim was reordered.
                public var didReorderProperties: Bool { get }

                /// Whether a spec was renamed.
                public var didRename: Bool { get }

                /// Whether a prim's variant sets list changed.
                public var didChangePrimVariantSets: Bool { get }

                /// Whether a prim's inherit paths list changed.
                public var didChangePrimInheritPaths: Bool { get }

                /// Whether a prim's specializes list changed.
                public var didChangePrimSpecializes: Bool { get }

                /// Whether a prim's references list changed.
                public var didChangePrimReferences: Bool { get }

                /// Whether an attribute's time samples changed.
                public var didChangeAttributeTimeSamples: Bool { get }

                /// Whether an attribute's connection targets changed.
                public var didChangeAttributeConnection: Bool { get }

                /// Whether a relationship's target list changed.
                public var didChangeRelationshipTargets: Bool { get }

                /// Whether a target was added to a relationship.
                public var didAddTarget: Bool { get }

                /// Whether a target was removed from a relationship.

Truncated.

extension USDLayer : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDLayer, rhs: USDLayer) -> Bool
}

extension USDLayer : Hashable {

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDLayer : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension USDLayer.AssetPath {

    /// The authored path string — the value as written in the USD file.
    public var authoredPath: String { get }

    /// The resolved location after asset resolution, or `nil` if resolution
    /// did not run or failed.
    public var resolvedPath: String? { get }
}

extension USDLayer.AssetPath : ExpressibleByStringLiteral {

    /// Creates an instance initialized to the given string value.
    ///
    /// - Parameter value: The value of the new instance.
    public init(stringLiteral value: String)

    /// A type that represents an extended grapheme cluster literal.
    ///
    /// Valid types for `ExtendedGraphemeClusterLiteralType` are `Character`,
    /// `String`, and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias ExtendedGraphemeClusterLiteralType = String

    /// A type that represents a string literal.
    ///
    /// Valid types for `StringLiteralType` are `String` and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias StringLiteralType = String

    /// A type that represents a Unicode scalar literal.
    ///
    /// Valid types for `UnicodeScalarLiteralType` are `Unicode.Scalar`,
    /// `Character`, `String`, and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias UnicodeScalarLiteralType = String
}

extension USDLayer.AssetPath : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDLayer.AssetPath, rhs: USDLayer.AssetPath) -> Bool
}

extension USDLayer.AssetPath : Hashable {

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDLayer.AssetPath : USDValueProtocol {
}

extension USDLayer.AssetPath : @unchecked Sendable {
}

extension USDLayer.AssetPath : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension USDLayer.ChangeList : @unchecked Sendable {
}

extension USDLayer.ChangeList : CustomStringConvertible, CustomDebugStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// A textual representation of this instance, suitable for debugging.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(reflecting:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `debugDescription` property for types that conform to
    /// `CustomDebugStringConvertible`:
    ///
    ///     struct Point: CustomDebugStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var debugDescription: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(reflecting: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `debugDescription` property.
    public var debugDescription: String { get }
}

extension USDLayer.ChangeList.Entry : @unchecked Sendable {
}

extension USDLayer.ChangeList.Entry : CustomStringConvertible, CustomDebugStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// A textual representation of this instance, suitable for debugging.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(reflecting:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `debugDescription` property for types that conform to
    /// `CustomDebugStringConvertible`:
    ///
    ///     struct Point: CustomDebugStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var debugDescription: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(reflecting: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `debugDescription` property.
    public var debugDescription: String { get }
}

extension USDLayer.ChangeList.Entry.Flags : @unchecked Sendable {
}

extension USDLayer.ChangeList.Entry.Flags : CustomStringConvertible, CustomDebugStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// A textual representation of this instance, suitable for debugging.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(reflecting:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `debugDescription` property for types that conform to
    /// `CustomDebugStringConvertible`:
    ///
    ///     struct Point: CustomDebugStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var debugDescription: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(reflecting: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `debugDescription` property.
    public var debugDescription: String { get }
}

extension USDLayer.ChangeList.Entry.InfoChange : @unchecked Sendable {
}

extension USDLayer.ListOperation : @unchecked Sendable {
}

extension USDLayer.ListOperation : USDValueProtocol {
}

extension USDLayer.ListOperationType : Equatable {
}

extension USDLayer.ListOperationType : Hashable {
}

extension USDLayer.Path {

    /// Returns a new path with the leaf name replaced.
    ///
    /// - Parameter newName: The new leaf name.
    /// - Returns: A new path with `newName` as its leaf.
    public func replacing(name newName: USDToken) -> USDLayer.Path

    /// Returns a new path with the target component replaced.
    ///
    /// - Parameter newTarget: The new target path.
    /// - Returns: A new path with the target component replaced.
    public func replacing(target newTarget: USDLayer.Path) -> USDLayer.Path

    /// Returns a new path with all variant selections removed.
    ///
    /// - Returns: A new path stripped of variant selections.
    public func strippingAllVariantSelections() -> USDLayer.Path

    /// Returns this path made absolute, anchored at the given path.
    ///
    /// - Parameter anchor: The absolute path to use as the anchor.
    /// - Returns: An absolute version of this path.
    public func absolute(at anchor: USDLayer.Path) -> USDLayer.Path

    /// Returns this path made relative to the given anchor.
    ///
    /// - Parameter anchor: The path to make this path relative to.
    /// - Returns: A relative version of this path.
    public func relative(to anchor: USDLayer.Path) -> USDLayer.Path

    /// Returns a Boolean value that indicates whether this path begins
    /// with `prefix`.
    ///
    /// - Parameter prefix: The candidate prefix path.
    /// - Returns: `true` if this path is rooted at `prefix`; otherwise, `false`.
    public func hasPrefix(_ prefix: USDLayer.Path) -> Bool

    /// Returns the longest common ancestor path of this path and `other`.
    ///
    /// - Parameter other: The path to compare against.
    /// - Returns: The longest path that is a prefix of both.
    public func commonPrefix(with other: USDLayer.Path) -> USDLayer.Path
}

extension USDLayer.Path : ExpressibleByStringLiteral {

    /// Creates an instance initialized to the given string value.
    ///
    /// - Parameter value: The value of the new instance.
    public init(stringLiteral: String)

    /// A type that represents an extended grapheme cluster literal.
    ///
    /// Valid types for `ExtendedGraphemeClusterLiteralType` are `Character`,
    /// `String`, and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias ExtendedGraphemeClusterLiteralType = String

    /// A type that represents a string literal.
    ///
    /// Valid types for `StringLiteralType` are `String` and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias StringLiteralType = String

    /// A type that represents a Unicode scalar literal.
    ///
    /// Valid types for `UnicodeScalarLiteralType` are `Unicode.Scalar`,
    /// `Character`, `String`, and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias UnicodeScalarLiteralType = String
}

extension USDLayer.Path : ExpressibleByStringInterpolation {

    /// The type each segment of a string literal containing interpolations
    /// should be appended to.
    ///
    /// The `StringLiteralType` of an interpolation type must match the
    /// `StringLiteralType` of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias StringInterpolation = DefaultStringInterpolation
}

extension USDLayer.Path : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDLayer.Path, rhs: USDLayer.Path) -> Bool
}

extension USDLayer.Path : Comparable {

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is less than that of the second argument.
    ///
    /// This function is the only requirement of the `Comparable` protocol. The
    /// remainder of the relational operator functions are implemented by the
    /// standard library for any type that conforms to `Comparable`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func < (lhs: USDLayer.Path, rhs: USDLayer.Path) -> Bool
}

extension USDLayer.Path : Hashable {

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDLayer.Path : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension USDLayer.Path : USDValueProtocol {
}

extension USDLayer.Path.Kind : Equatable {
}

extension USDLayer.Path.Kind : Hashable {
}

extension USDLayer.PathExpression : ExpressibleByStringLiteral {

    /// Creates an instance initialized to the given string value.
    ///
    /// - Parameter value: The value of the new instance.
    public init(stringLiteral value: String)

    /// A type that represents an extended grapheme cluster literal.
    ///
    /// Valid types for `ExtendedGraphemeClusterLiteralType` are `Character`,
    /// `String`, and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias ExtendedGraphemeClusterLiteralType = String

    /// A type that represents a string literal.
    ///
    /// Valid types for `StringLiteralType` are `String` and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias StringLiteralType = String

    /// A type that represents a Unicode scalar literal.
    ///
    /// Valid types for `UnicodeScalarLiteralType` are `Unicode.Scalar`,
    /// `Character`, `String`, and `StaticString`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias UnicodeScalarLiteralType = String
}

extension USDLayer.PathExpression : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension USDLayer.PathExpression : @unchecked Sendable {
}

extension USDLayer.PathExpression : USDValueProtocol {
}

extension USDLayer.PathExpression : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension USDLayer.Permission : USDValueProtocol {
}

extension USDLayer.Spec {

    /// Widens a `USDPrim.VariantSetSpec` into an untyped ``USDLayer/Spec``.
    public init(_ variantSetSpec: USDPrim.VariantSetSpec)
}

extension USDLayer.Spec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDLayer.Spec, rhs: USDLayer.Spec) -> Bool
}

extension USDLayer.Spec : USDLayer.Spec.MetadataCollection {
}

extension USDLayer.Spec : USDLayer.Spec.FieldCollection {
}

extension USDLayer.Spec.FieldCollection {

    /// All authored field names on this spec.
    public var fields: [USDToken] { get }

    /// Returns the value of `name`, or `nil` if the field is unauthored.
    ///
    /// - Parameter name: The field name to look up.
    /// - Returns: The field's value, or `nil` if unauthored.
    public func field(_ name: USDToken) -> USDValue?

    /// Sets the field `name` to `value`.
    ///
    /// - Parameters:
    ///   - name: The field name.
    ///   - value: The new value.
    /// - Returns: `true` on success.
    @discardableResult
    public func setField(_ name: USDToken, to value: USDValue) -> Bool

    /// Clears the authored value for `name`.
    ///
    /// - Parameter name: The field name to clear.
    /// - Returns: `true` if the field had been authored.
    @discardableResult
    public func clearField(_ name: USDToken) -> Bool

    /// Typed field accessor.
    ///
    /// - Parameters:
    ///   - name: The field name to look up.
    ///   - type: The expected value type.
    /// - Returns: The field's value as `T`, or `nil` if the field is
    ///   unauthored or holds a different type.
    public func field<T>(_ name: USDToken, as type: T.Type) -> T? where T : USDValueProtocol

    /// Typed field setter.
    ///
    /// - Parameters:
    ///   - name: The field name to author.
    ///   - value: The typed value to store.
    /// - Returns: `true` on success.
    @discardableResult
    public func setField<T>(_ name: USDToken, to value: T) -> Bool where T : USDValueProtocol

    /// Returns a Boolean value that indicates whether the spec contains
    /// no authored data.
    ///
    /// - Parameter ignoringChildren: Pass `true` to skip child specifier
    ///   lists when evaluating inertness.
    /// - Returns: `true` if the spec has no authored data.
    public func isInert(ignoringChildren: Bool = false) -> Bool
}

extension USDLayer.Spec.MetadataCollection {

    /// The kind of spec, or `nil` if the spec is dormant.
    public var specType: USDLayer.SpecType? { get }

    /// Whether the spec is dormant (the underlying data has been removed).
    public var isDormant: Bool { get }

    /// The layer containing this spec, or `nil` if dormant.
    public var layer: USDLayer? { get }

    /// The path identifying this spec within its layer.
    public var path: USDLayer.Path { get }

    /// All authored info keys on this spec, including structural fields
    /// (child specifier lists, type info, etc.).
    public var infoKeys: [USDToken] { get }

    /// The subset of info keys an inspector should treat as user-visible
    /// metadata. Excludes structural fields.
    public var metadataInfoKeys: [USDToken] { get }

    /// Returns the value of `key`, or `nil` if the key is unauthored.
    ///
    /// - Parameter key: The info key to look up.
    /// - Returns: The authored value, or `nil` if unauthored.
    public func info(_ key: USDToken) -> USDValue?

    /// Sets `key` to `value`.
    ///
    /// - Parameters:
    ///   - key: The info key to author.
    ///   - value: The new value.
    public func setInfo(_ key: USDToken, to value: USDValue)

    /// Clears the authored value for `key`.
    ///
    /// - Parameter key: The info key to clear.
    public func clearInfo(_ key: USDToken)
}

extension USDLayer.TimeCode : Equatable, Comparable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDLayer.TimeCode, rhs: USDLayer.TimeCode) -> Bool

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is less than that of the second argument.
    ///
    /// This function is the only requirement of the `Comparable` protocol. The
    /// remainder of the relational operator functions are implemented by the
    /// standard library for any type that conforms to `Comparable`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func < (lhs: USDLayer.TimeCode, rhs: USDLayer.TimeCode) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDLayer.TimeCode : ExpressibleByFloatLiteral {

    /// Creates an instance initialized to the specified floating-point value.
    ///
    /// Do not call this initializer directly. Instead, initialize a variable or
    /// constant using a floating-point literal. For example:
    ///
    ///     let x = 21.5
    ///
    /// In this example, the assignment to the `x` constant calls this
    /// floating-point literal initializer behind the scenes.
    ///
    /// - Parameter value: The value to create.
    public init(floatLiteral value: Double)

    /// A type that represents a floating-point literal.
    ///
    /// Valid types for `FloatLiteralType` are `Float`, `Double`, and `Float80`
    /// where available.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias FloatLiteralType = Double
}

extension USDLayer.TimeCode : USDValueProtocol {
}

extension USDLayer.TimeCode : USDPrim.Attribute.Value {

    public static var valueType: USDPrim.Attribute.ValueType { get }
}

extension USDLayer.TimeOffset : @unchecked Sendable {
}

extension USDLayer.TimeOffset : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDLayer.TimeOffset, rhs: USDLayer.TimeOffset) -> Bool
}

extension USDLayer.TimeOffset : Hashable {

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDLayer.TimeOffset : USDValueProtocol {
}

public struct USDPrim {

    /// An invalid prim handle.
    public init()

    /// Casts an object handle to a prim handle.
    ///
    /// Returns `nil` if the object is not a prim.
    public init?(_ object: USDStage.Object)

    /// A Boolean value indicating whether this prim is valid.
    ///
    /// A prim's validity is connected to a ``USDStage``. A prim becomes invalid
    /// when the lifetime of its stage ends.
    ///
    /// A prim will also expire if its stage no longer defines that prim.
    /// `isValid` is false if this prim has expired.
    public var isValid: Bool { get }

    /// The stage that owns this prim.
    ///
    /// A prim's state and validity is connected to its stage. A prim becomes
    /// invalid when the lifetime of its stage ends. It can also become invalid
    /// when the stage is modified.
    public var stage: USDStage { get }

    /// The complete scene path to this prim, relative to its stage.
    public var path: USDLayer.Path { get }

    /// The complete scene path to this prim, relative to its stage.
    ///
    /// This property is equivalent to ``path``.
    public var primPath: USDLayer.Path { get }

    public var specifier: USDPrim.Specifier { get }

    /// The active, loaded, defined, non-abstract child prims of this prim.
    public var children: [USDPrim] { get }

    /// The child prims of this prim.
    public var allChildren: [USDPrim] { get }

    /// Returns the child prims of this prim that satisfy the given predicate.
    public func children(where predicate: USDPrim.Predicate) -> [USDPrim]

    /// The active, loaded, defined, non-abstract descendant prims of this prim, in depth-first order.
    public var descendants: [USDPrim] { get }

    /// The descendant prims of this prim.
    public var allDescendants: [USDPrim] { get }

    /// Returns the descendant prims of this prim that satisfy the given predicate.
    public func descendants(where predicate: USDPrim.Predicate) -> [USDPrim]

    /// The immediate parent prim of this prim.
    public var parent: USDPrim? { get }

    /// The active, loaded, defined, non-abstract successor of this prim in its parent's list of children.
    public var nextSibling: USDPrim? { get }

    /// The successor of this prim in its parent's list of children that satisfies the given predicate.
    public func nextSibling(where predicate: USDPrim.Predicate) -> USDPrim

    /// Returns the prim at a given path, relative to this prim.
    ///
    /// If `path` is relative, it is anchored to this prim's path. If no prim
    /// exists at the resolved path, returns an invalid prim handle.
    public func prim(at path: USDLayer.Path) -> USDPrim

    /// Returns the object at a given path, relative to this prim.
    ///
    /// If `path` is relative, it is anchored to this prim's path. If no object
    /// exists at the resolved path, returns an invalid object handle.
    public func object(at path: USDLayer.Path) -> USDStage.Object

    /// Access or modify the value of a named attribute on this prim.
    public subscript<T>(attributeName: USDToken, as type: T.Type) -> T? where T : USDPrim.Attribute.Value { get nonmutating set }

    public func attribute(at path: USDLayer.Path) -> USDPrim.Attribute

Truncated.

extension USDPrim {

    /// A handle to a variant set — a named group of variant options.
    public struct VariantSetSpec {

        /// Creates an empty (invalid) variant set spec handle.
        public init()

        /// Narrows an untyped ``USDLayer/Spec`` to a variant set spec.
        ///
        /// - Parameter spec: The spec to narrow.
        /// - Returns: A variant set spec, or `nil` if `spec` is not a
        ///   variant set spec.
        public init?(_ spec: USDLayer.Spec)

        /// Creates a new variant set spec under the given prim spec.
        ///
        /// - Parameters:
        ///   - owner: The prim spec that owns the new variant set.
        ///   - name: The variant set's name.
        public init?(owner: USDPrim.Spec, name: USDToken)

        /// Creates a new variant set spec nested inside a variant spec.
        ///
        /// - Parameters:
        ///   - owner: The variant spec that owns the new (nested) variant set.
        ///   - name: The variant set's name.
        public init?(owner: USDPrim.VariantSpec, name: USDToken)
    }
}

extension USDPrim : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim, rhs: USDPrim) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDPrim : CustomStringConvertible {

    /// A summary description of this prim.
    ///
    /// This property is safe to access on an invalid or expired prim.
    public var description: String { get }
}

extension USDPrim : USDStage.Object.MetadataCollection {
}

extension USDPrim.Attribute {

    /// A handle to an attribute definition stored in a layer.
    ///
    /// `USDPrim.Attribute.Spec` is a struct but acts as a handle into data
    /// owned by a ``USDLayer``. Mutations write through to the layer.
    public struct Spec {

        /// Creates an empty (invalid) attribute spec handle.
        public init()

        /// Narrows an untyped ``USDLayer/Spec`` to an attribute spec.
        ///
        /// - Parameter spec: The spec to narrow.
        /// - Returns: An attribute spec, or `nil` if `spec` is not an
        ///   attribute spec.
        public init?(_ spec: USDLayer.Spec)

        /// Creates a new attribute spec under the given prim spec.
        ///
        /// - Parameters:
        ///   - owner: The prim spec that owns the new attribute.
        ///   - name: The attribute's name.
        ///   - typeName: The attribute's value type.
        ///   - variability: The attribute's variability.
        ///   - isCustom: Whether the attribute is authored as `custom`.
        public init?(owner: USDPrim.Spec, name: USDToken, typeName: USDPrim.Attribute.ValueType, variability: USDPrim.Property.Variability = .varying, isCustom: Bool = false)

        /// Creates an attribute spec at the given path in the layer, authoring
        /// intermediate ancestor prim specs as `over`s where needed.
        ///
        /// - Parameters:
        ///   - layer: The layer that owns the new attribute.
        ///   - attributePath: The full path of the attribute to author.
        ///   - typeName: The attribute's value type.
        ///   - variability: The attribute's variability.
        ///   - isCustom: Whether the attribute is authored as `custom`.
        public init?(layer: USDLayer, attributePath: USDLayer.Path, typeName: USDPrim.Attribute.ValueType, variability: USDPrim.Property.Variability = .varying, isCustom: Bool = false)
    }
}

extension USDPrim.Attribute : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Attribute, rhs: USDPrim.Attribute) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDPrim.Attribute : CustomStringConvertible {

    /// A summary description of this attribute.
    ///
    /// This property is safe to access on an invalid or expired attribute.
    public var description: String { get }
}

extension USDPrim.Attribute : USDStage.Object.MetadataCollection {
}

extension USDPrim.Attribute.Spec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Attribute.Spec, rhs: USDPrim.Attribute.Spec) -> Bool
}

extension USDPrim.Attribute.Spec : USDLayer.Spec.MetadataCollection {
}

extension USDPrim.Attribute.Spec : USDLayer.Spec.FieldCollection {
}

extension USDPrim.Attribute.Spec : USDPrim.Property.Spec.SymmetryCollection, USDPrim.Property.Spec.ValueCollection {
}

extension USDPrim.Attribute.Spec {

    /// The authored connection paths, or `nil` if none authored.
    public var connectionPaths: [USDLayer.Path]? { get }

    /// Clears all authored connection paths on this attribute.
    public func clearConnectionPaths()

    /// The authored color space, or `nil` if not authored.
    /// Assigning `nil` clears the color space.
    public var colorSpace: USDToken? { get nonmutating set }
}

extension USDPrim.Attribute.ValueType : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Attribute.ValueType, rhs: USDPrim.Attribute.ValueType) -> Bool
}

extension USDPrim.Attribute.ValueType : Hashable {

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDPrim.Attribute.ValueType : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension USDPrim.Attribute.ValueType {

    /// The shape of a value type's components.
    ///
    /// - `scalar`: a single value (e.g. `Float`, `Int`).
    /// - `vector(n)`: an n-component tuple (e.g. `Float3` is `.vector(3)`).
    /// - `matrix(rows:cols:)`: a 2D tuple (e.g. `Matrix4d` is `.matrix(rows: 4, cols: 4)`).
    public enum TupleDimensions : Equatable, Sendable, Hashable {

        case scalar

        case vector(Int)

        case matrix(rows: Int, columns: Int)

        /// The total number of components across all dimensions.
        public var componentCount: Int { get }

        /// Returns a Boolean value indicating whether two values are equal.
        ///
        /// Equality is the inverse of inequality. For any values `a` and `b`,
        /// `a == b` implies that `a != b` is `false`.
        ///
        /// - Parameters:
        ///   - lhs: A value to compare.
        ///   - rhs: Another value to compare.
        public static func == (a: USDPrim.Attribute.ValueType.TupleDimensions, b: USDPrim.Attribute.ValueType.TupleDimensions) -> Bool

        /// Hashes the essential components of this value by feeding them into the
        /// given hasher.
        ///
        /// Implement this method to conform to the `Hashable` protocol. The
        /// components used for hashing must be the same as the components compared
        /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
        /// with each of these components.
        ///
        /// - Important: In your implementation of `hash(into:)`,
        ///   don't call `finalize()` on the `hasher` instance provided,
        ///   or replace it with a different instance.
        ///   Doing so may become a compile-time error in the future.
        ///
        /// - Parameter hasher: The hasher to use when combining the components
        ///   of this instance.
        public func hash(into hasher: inout Hasher)

        /// The hash value.
        ///
        /// Hash values are not guaranteed to be equal across different executions of
        /// your program. Do not save hash values to use during a future execution.
        ///
        /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
        ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
        ///   The compiler provides an implementation for `hashValue` for you.
        public var hashValue: Int { get }
    }
}

extension USDPrim.ListPosition : Equatable {
}

extension USDPrim.ListPosition : Hashable {
}

extension USDPrim.ListPosition : RawRepresentable {
}

extension USDPrim.Payload : @unchecked Sendable {
}

extension USDPrim.Payload : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Payload, rhs: USDPrim.Payload) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDPrim.Predicate : CustomStringConvertible {

    /// A summary description of this predicate.
    public var description: String { get }
}

extension USDPrim.Property {

    public init(_ relationship: USDPrim.Relationship)
}

extension USDPrim.Property : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Property, rhs: USDPrim.Property) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDPrim.Property : CustomStringConvertible {

    /// A summary description of this property.
    ///
    /// `description` is safe to access on an invalid or expired property.
    public var description: String { get }
}

extension USDPrim.Property : USDStage.Object.MetadataCollection {
}

extension USDPrim.Property.Spec {

    /// Value-related API for property specs that hold typed default values.
    ///
    /// Only `USDPrim.Property.Spec` and `USDPrim.Attribute.Spec` conform to
    /// this protocol; `USDPrim.Relationship.Spec` does not, because
    /// relationships don't store typed values.
    public protocol ValueCollection {
    }
}

extension USDPrim.Property.Spec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Property.Spec, rhs: USDPrim.Property.Spec) -> Bool
}

extension USDPrim.Property.Spec : USDLayer.Spec.MetadataCollection {
}

extension USDPrim.Property.Spec : USDLayer.Spec.FieldCollection {
}

extension USDPrim.Property.Spec : USDPrim.Property.Spec.SymmetryCollection, USDPrim.Property.Spec.ValueCollection {
}

extension USDPrim.Property.Spec.SymmetryCollection {

    /// The symmetric peer path, or `nil` if not authored.
    public var symmetricPeer: String? { get nonmutating set }

    /// The symmetry function token, or `nil` if not authored.
    public var symmetryFunction: USDToken? { get nonmutating set }

    /// The symmetry arguments dictionary authored on this property.
    public var symmetryArguments: [String : USDValue] { get }

    /// Sets `name` in the symmetry arguments dictionary to `value`.
    ///
    /// - Parameters:
    ///   - name: The argument name.
    ///   - value: The new value.
    public func setSymmetryArgument(_ name: String, to value: USDValue)

    /// Removes `name` from the symmetry arguments dictionary.
    ///
    /// - Parameter name: The argument name to clear.
    public func clearSymmetryArgument(_ name: String)

    /// The authored prefix used for symmetry-driven name substitution,
    /// or `nil` if not authored.
    public var prefix: String? { get nonmutating set }

    /// The authored suffix used for symmetry-driven name substitution,
    /// or `nil` if not authored.
    public var suffix: String? { get nonmutating set }
}

extension USDPrim.Property.Spec.ValueCollection {

    /// The property's value type.
    public var typeName: USDPrim.Attribute.ValueType { get }

    /// The property's variability (varying, uniform, or config).
    public var variability: USDPrim.Property.Variability { get }

    /// The authored default value, or `nil` if not authored.
    /// Assigning `nil` clears the default.
    public var defaultValue: USDValue? { get nonmutating set }
}

extension USDPrim.Property.Variability : USDValueProtocol {
}

extension USDPrim.PseudoRootSpec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.PseudoRootSpec, rhs: USDPrim.PseudoRootSpec) -> Bool
}

extension USDPrim.PseudoRootSpec : USDLayer.Spec.MetadataCollection {
}

extension USDPrim.PseudoRootSpec : USDLayer.Spec.FieldCollection {
}

extension USDPrim.Reference : @unchecked Sendable {
}

extension USDPrim.Reference : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Reference, rhs: USDPrim.Reference) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDPrim.Relationship {

    /// A handle to a relationship definition stored in a layer.
    ///
    /// Relationships store connections to other prims (target paths) rather
    /// than typed values. Used for scene linkages like material bindings,
    /// collection membership, and proxy references.
    public struct Spec {

        /// Creates an empty (invalid) relationship spec handle.
        public init()

        /// Narrows an untyped ``USDLayer/Spec`` to a relationship spec.
        ///
        /// - Parameter spec: The spec to narrow.
        /// - Returns: A relationship spec, or `nil` if `spec` is not a
        ///   relationship spec.
        public init?(_ spec: USDLayer.Spec)

        /// Creates a new relationship spec under the given prim spec.
        ///
        /// - Parameters:
        ///   - owner: The prim spec that owns the new relationship.
        ///   - name: The relationship's name.
        ///   - variability: The relationship's variability.
        ///   - isCustom: Whether the relationship is authored as `custom`.
        public init?(owner: USDPrim.Spec, name: USDToken, variability: USDPrim.Property.Variability = .varying, isCustom: Bool = true)

        /// Creates a relationship spec at the given path in the layer,
        /// authoring intermediate ancestor prim specs as `over`s where needed.
        ///
        /// - Parameters:
        ///   - layer: The layer that owns the new relationship.
        ///   - relationshipPath: The full path of the relationship to author.
        ///   - variability: The relationship's variability.
        ///   - isCustom: Whether the relationship is authored as `custom`.
        public init?(layer: USDLayer, relationshipPath: USDLayer.Path, variability: USDPrim.Property.Variability = .varying, isCustom: Bool = false)
    }
}

extension USDPrim.Relationship : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Relationship, rhs: USDPrim.Relationship) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDPrim.Relationship : CustomStringConvertible {

    /// A summary description of this relationship.
    ///
    /// This property is safe to access on an invalid or expired relationship.
    public var description: String { get }
}

extension USDPrim.Relationship : USDStage.Object.MetadataCollection {
}

extension USDPrim.Relationship.Spec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Relationship.Spec, rhs: USDPrim.Relationship.Spec) -> Bool
}

extension USDPrim.Relationship.Spec : USDLayer.Spec.MetadataCollection {
}

extension USDPrim.Relationship.Spec : USDLayer.Spec.FieldCollection {
}

extension USDPrim.Relationship.Spec : USDPrim.Property.Spec.SymmetryCollection {
}

extension USDPrim.Relationship.Spec {

    /// The authored target paths, or `nil` if none authored.
    public var targetPaths: [USDLayer.Path]? { get }

    /// Clears all authored target paths on this relationship.
    public func clearTargetPaths()

    /// Replaces an authored target path with a new path.
    ///
    /// - Parameters:
    ///   - oldPath: The existing target path.
    ///   - newPath: The replacement target path.
    public func replaceTarget(_ oldPath: USDLayer.Path, with newPath: USDLayer.Path)

    /// Removes an authored target path.
    ///
    /// - Parameters:
    ///   - path: The target path to remove.
    ///   - preservingOrder: Pass `true` to keep the relative ordering
    ///     of remaining targets stable.
    public func removeTarget(_ path: USDLayer.Path, preservingOrder: Bool = false)

    /// Hint to the runtime to skip loading payloads on targeted prims.
    /// Default: `false`.
    public var noLoadHint: Bool { get nonmutating set }
}

extension USDPrim.Spec {

    /// The variant sets authored on this prim, keyed by name.
    public var variantSets: [USDToken : USDPrim.VariantSetSpec] { get }
}

extension USDPrim.Spec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.Spec, rhs: USDPrim.Spec) -> Bool
}

extension USDPrim.Spec : USDLayer.Spec.MetadataCollection {
}

extension USDPrim.Spec : USDLayer.Spec.FieldCollection {
}

extension USDPrim.Specifier : USDValueProtocol {
}

extension USDPrim.VariantSetSpec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.VariantSetSpec, rhs: USDPrim.VariantSetSpec) -> Bool
}

extension USDPrim.VariantSetSpec : USDLayer.Spec.MetadataCollection {
}

extension USDPrim.VariantSetSpec : USDLayer.Spec.FieldCollection {
}

extension USDPrim.VariantSetSpec {

    /// The variant set's local name.
    public var name: USDToken { get }

    /// The owning spec — a prim spec or variant spec.
    public var owner: USDLayer.Spec? { get }

    /// All variant specs in this set.
    public var variants: [USDPrim.VariantSpec] { get }

    /// Removes the given variant spec from this set.
    ///
    /// - Parameter variant: The variant spec to remove.
    public func removeVariant(_ variant: USDPrim.VariantSpec)
}

extension USDPrim.VariantSpec : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDPrim.VariantSpec, rhs: USDPrim.VariantSpec) -> Bool
}

extension USDPrim.VariantSpec : USDLayer.Spec.MetadataCollection {
}

extension USDPrim.VariantSpec : USDLayer.Spec.FieldCollection {
}

extension USDPrim.VariantSpec {

    /// The variant's local name.
    public var name: USDToken { get }

    /// The owning variant set spec.
    public var owner: USDPrim.VariantSetSpec? { get }

    /// The prim spec this variant authors when selected.
    public var primSpec: USDPrim.Spec? { get }

    /// Variant sets defined inside this variant (nested variation).
    public var variantSets: [USDToken : USDPrim.VariantSetSpec] { get }

    /// Returns the variant names available in a nested variant set on
    /// this variant.
    ///
    /// - Parameter variantSetName: The nested variant set name.
    /// - Returns: The variant names defined in `variantSetName`.
    public func variantNames(_ variantSetName: USDToken) -> [USDToken]
}

public struct USDRenderError : Error, Sendable {

    /// Retrieve the localized description for this error.
    public var localizedDescription: String
}

public struct UsdRenderMessage : Equatable, CustomStringConvertible, CustomDebugStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }

    /// A textual representation of this instance, suitable for debugging.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(reflecting:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `debugDescription` property for types that conform to
    /// `CustomDebugStringConvertible`:
    ///
    ///     struct Point: CustomDebugStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var debugDescription: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(reflecting: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `debugDescription` property.
    public var debugDescription: String { get }

    public enum MessageType : String {

        case warning

        case error

        case status

        case fatal

        /// Creates a new instance with the specified raw value.
        ///
        /// If there is no value of the type that corresponds with the specified raw
        /// value, this initializer returns `nil`. For example:
        ///
        ///     enum PaperSize: String {
        ///         case A4, A5, Letter, Legal
        ///     }
        ///
        ///     print(PaperSize(rawValue: "Legal"))
        ///     // Prints "Optional(PaperSize.Legal)"
        ///
        ///     print(PaperSize(rawValue: "Tabloid"))
        ///     // Prints "nil"
        ///
        /// - Parameter rawValue: The raw value to use for the new instance.
        public init?(rawValue: String)

Truncated.

extension UsdRenderMessage.MessageType : Equatable {
}

extension UsdRenderMessage.MessageType : Hashable {
}

extension UsdRenderMessage.MessageType : RawRepresentable {
}

public struct UsdStage {
}

public struct USDStage {

    /// Creates a new memory-backed stage.
    ///
    /// This is analogous to creating an anonymous ``SdfLayer``.
    public init(displayName: String? = nil, loadingPayloads: USDStage.InitialLoadRule = .all)

    /// Opens a stage rooted at a given layer.
    ///
    /// Recursively follows the composition rules described by `rootLayer`,
    /// opening any files referenced by the layer and assembling a hierarchy of
    /// ``USDPrim``s from the combined contents of all layers.
    ///
    /// This function creates a new, independent stage object even if there is
    /// already a stage opened with `rootLayer` as its root layer.
    ///
    /// Parameters:
    ///   - rootLayer: The root layer of the new stage.
    ///   - sessionLayer: A layer to use as a session layer. If `nil`, an anonymous layer will be created.
    ///   - options: Options that specify behavior related to opening a stage.
    public static func open(rootLayer: USDLayer, sessionLayer: USDLayer? = nil, options: USDStage.OpenOptions = []) throws -> USDStage

    /// Opens a stage using a file as the root layer.
    ///
    /// Recursively follows the composition rules described by the root layer,
    /// opening any files referenced by that layer and assembling a hierarchy of
    /// ``USDPrim``s from the combined contents of all layers.
    ///
    /// This function will not create a file if no file exists at `path`, unless
    /// ``OpenOptions.createNew`` is passed as an option.
    ///
    /// This function creates a new, independent stage object even if there is
    /// already a stage opened with `path` as its root layer.
    ///
    /// Parameters:
    ///   - path: A file to use as the root layer of the new stage.
    ///   - sessionLayer: A layer to use as a session layer. If `nil`, an anonymous layer will be created.
    ///   - options: Options that specify behavior related to opening a stage.
    ///
    /// Throws: An error if `path` does not exist or could not be read.
    public static func open(_ path: FilePath, sessionLayer: USDLayer? = nil, options: USDStage.OpenOptions = []) throws -> USDStage

    public static func open(_ url: URL, loadingPayloads: USDStage.InitialLoadRule = .all) throws -> USDStage

    public init(_ buffer: Data, type: UTType, loadingPayloads: USDStage.InitialLoadRule = .all) throws

    public init(string: String, loadingPayloads: USDStage.InitialLoadRule = .all) throws

    /// Options that specify behavior related to opening a stage.
    public struct OpenOptions : Sendable, ExpressibleByArrayLiteral {

        /// Creates a new layer instead of opening an existing file. Any existing
        /// file at the specified path will be overwritten.
        public static var createNew: USDStage.OpenOptions { get }

        /// Specifies the rule used to determine if referenced payloads are loaded.
        ///
        /// The default is `.all`, so all loadable prims will be automatically loaded.
        public static func loadRule(_ rule: USDStage.InitialLoadRule) -> USDStage.OpenOptions

        public init()

        /// Creates an instance initialized with the given elements.
        public init(arrayLiteral elements: USDStage.OpenOptions...)

        /// The type of the elements of an array literal.
        @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
        public typealias ArrayLiteralElement = USDStage.OpenOptions
    }

    /// Specifies the rule used when opening a stage to determine if referenced payloads are loaded.
    public enum InitialLoadRule : Hashable, Sendable {

        /// Load all loadable prims.
        case all

        /// Load no loadable prims.
        case none

        /// Returns a Boolean value indicating whether two values are equal.

Truncated.

extension USDStage {

    /// Exports the stage as a flattened USD file.
    ///
    /// Composes all layers into a single layer and writes it to the specified
    /// location. The output format is determined by the file extension.
    ///
    /// > Important: Flattening is destructive. Layer structure, composition arcs,
    /// and variant selections are resolved into the output. To preserve layer
    /// structure, use ``exportPackage(to:options:)`` instead.
    ///
    /// Throws an error if the extension is not `.usda`, `.usdc`, or `.usd`.
    public func exportFlattened(to url: URL) throws

    /// Exports the stage as a flattened USD file.
    public func exportFlattened(to path: FilePath) throws

    /// Packages the stage into a USDZ archive.
    ///
    /// The stage and its referenced assets are bundled into a USDZ file.
    /// Layer structure is preserved — this operation does not flatten.
    ///
    /// Throws an error if the extension is not `.usdz`.
    public func exportPackage(to url: URL, options: USDStage.ExportOptions = []) throws

    /// Packages the stage into a USDZ archive.
    public func exportPackage(to path: FilePath, options: USDStage.ExportOptions = []) throws

    /// Options for packaging a stage into a USDZ file.
    public struct ExportOptions : ExpressibleByArrayLiteral, Hashable, Sendable {

        /// A texture quality level.
        public struct TextureQuality : Hashable, Sendable {

            /// Reduces the texture file size while preserving most details.
            public static var standard: USDStage.ExportOptions.TextureQuality { get }

            /// Further reduces the texture file size.
            /// Fine details may not be preserved to reach a small file size.
            public static var medium: USDStage.ExportOptions.TextureQuality { get }

            /// Aggressively reduces the texture file size.
            /// Some visual details may be suppressed to reach the smallest file size.
            public static var low: USDStage.ExportOptions.TextureQuality { get }

            /// Returns a Boolean value indicating whether two values are equal.
            ///
            /// Equality is the inverse of inequality. For any values `a` and `b`,
            /// `a == b` implies that `a != b` is `false`.
            ///
            /// - Parameters:
            ///   - lhs: A value to compare.
            ///   - rhs: Another value to compare.
            public static func == (a: USDStage.ExportOptions.TextureQuality, b: USDStage.ExportOptions.TextureQuality) -> Bool

            /// Hashes the essential components of this value by feeding them into the
            /// given hasher.
            ///
            /// Implement this method to conform to the `Hashable` protocol. The
            /// components used for hashing must be the same as the components compared
            /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
            /// with each of these components.
            ///
            /// - Important: In your implementation of `hash(into:)`,
            ///   don't call `finalize()` on the `hasher` instance provided,
            ///   or replace it with a different instance.
            ///   Doing so may become a compile-time error in the future.
            ///
            /// - Parameter hasher: The hasher to use when combining the components
            ///   of this instance.
            public func hash(into hasher: inout Hasher)

            /// The hash value.
            ///
            /// Hash values are not guaranteed to be equal across different executions of
            /// your program. Do not save hash values to use during a future execution.
            ///
            /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
            ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
            ///   The compiler provides an implementation for `hashValue` for you.

Truncated.

extension USDStage : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDStage, rhs: USDStage) -> Bool
}

extension USDStage.EditTarget : Equatable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDStage.EditTarget, rhs: USDStage.EditTarget) -> Bool
}

extension USDStage.Object {

    public init(_ relationship: USDPrim.Relationship)
}

extension USDStage.Object : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: USDStage.Object, rhs: USDStage.Object) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

extension USDStage.Object : CustomStringConvertible {

    /// A summary description of this object.
    ///
    /// This property is safe to access on an invalid or expired object.
    public var description: String { get }
}