What's new in ComputeGraph

public enum AddressSpace : Equatable, Sendable, Codable {

    case constant

    case device

    case threadgroup

    case thread

    /// 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: AddressSpace, b: AddressSpace) -> Bool

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws

    /// 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 }

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws
}

extension AddressSpace : Hashable {
}

public struct AdvanceParams {

    /// The time interval, in seconds, to advance the simulation.
    ///
    /// When ``SimulationRate/mode`` is ``SimulationRate/Mode-swift.enum/fixedFrequency``
    /// or ``SimulationRate/Mode-swift.enum/fixedTime``, the simulation takes
    /// between zero and ``maxSteps`` fixed-size steps to consume this interval.
    /// Any remaining time is accumulated and carried into the next advance.
    public var deltaTime: Float

    /// The maximum number of fixed-size steps per advance.
    ///
    /// This value is only used when ``SimulationRate/mode`` is
    /// ``SimulationRate/Mode-swift.enum/fixedFrequency`` or
    /// ``SimulationRate/Mode-swift.enum/fixedTime``.
    public var maxSteps: Int

    /// The command buffer to encode simulation commands into.
    public var commandBuffer: any MTLCommandBuffer

    /// The compute command encoder to encode simulation dispatches with.
    public var computeEncoder: any MTLComputeCommandEncoder

    /// The transform from the system's local space to world space.
    ///
    /// How this matrix is applied depends on the graph's coordinateSpace.
    public var localToWorld: simd_float4x4

    /// The transform from world space to the system's local space.
    ///
    /// How this matrix is applied depends on the graph's coordinateSpace.
    public var worldToLocal: simd_float4x4

    /// The position of the viewer in world space.
    ///
    /// When provided, this value can be used for billboarding or
    /// read within the graph for viewer-relative effects.
    public var viewPosition: SIMD3<Float>?

    /// The forward direction of the viewer in world space.
    ///
    /// When provided, this value can be used for billboarding or
    /// read within the graph for viewer-relative effects.
    public var viewDirection: SIMD3<Float>?

    /// Creates advance parameters with the required Metal objects.
    ///
    /// - Parameters:
    ///   - deltaTime: The time interval, in seconds, to advance the simulation.
    ///   - commandBuffer: The command buffer to encode simulation commands into.
    ///   - computeEncoder: The compute command encoder to use.
    public init(deltaTime: Float, commandBuffer: any MTLCommandBuffer, computeEncoder: any MTLComputeCommandEncoder)
}

public enum BinaryOperation : String, Codable, CaseIterable, Sendable {

    case add

    case sub

    case mul

    case div

    case modulus

    case greaterThan

    case lessThan

    case greaterThanOrEqual

    case lessThanOrEqual

    case equalTo

    case notEqualTo

    case bitwiseAnd

    case bitwiseOr

    case bitwiseXor

    case logicalAnd

    case logicalOr

    case shiftRight

    case shiftLeft

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [BinaryOperation]

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [BinaryOperation] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }

Truncated.

extension BinaryOperation : Equatable {
}

extension BinaryOperation : Hashable {
}

extension BinaryOperation : RawRepresentable {
}

extension ComputeGraphSimulation.AdvanceParams {

    public init(deltaTime: Float, commandBuffer: any MTLCommandBuffer, computeEncoder: any MTLComputeCommandEncoder, localToWorld: simd_float4x4, worldToLocal: simd_float4x4, viewPosition: SIMD3<Float>? = nil, viewDirection: SIMD3<Float>? = nil)
}

extension ComputeGraphSimulation.SimulationRate.Mode : Equatable {
}

extension ComputeGraphSimulation.SimulationRate.Mode : Hashable {
}

extension ComputeGraphSimulation.SimulationRate.Mode : RawRepresentable {
}

public struct ComputeNodeGraph : Sendable, Equatable {

    public typealias NodeID = Int

    public var nodes: [ComputeNodeGraph.NodeID : ComputeNodeGraph.Node]

    public var edges: [ComputeNodeGraph.Edge] { get }

    public init()

    /// 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: ComputeNodeGraph, b: ComputeNodeGraph) -> Bool
}

extension ComputeNodeGraph.Port.Kind : Hashable {
}

extension ComputeNodeGraph.SamplerSettings : Codable {

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws
}

extension ComputeNodeGraph.Stage {

    /// Spawns new particles into the system.
    public static let emission: ComputeNodeGraph.Stage

    /// Sets initial values for newly spawned particles.
    public static let initialize: ComputeNodeGraph.Stage

    /// A stage that receives events from a simulation (e.g. update or terminate), and
    /// initializes new particles for another simulation.
    public static let eventSource: ComputeNodeGraph.Stage

    /// Updates particle state each frame (position, velocity, lifetime, etc.).
    public static let simulate: ComputeNodeGraph.Stage

    /// Produces final per-particle results for rendering.
    public static let output: ComputeNodeGraph.Stage

    /// A general-purpose computation stage.
    public static let compute: ComputeNodeGraph.Stage

    /// Generates texture data.
    public static let texture: ComputeNodeGraph.Stage

    public init(_ name: String)

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws
}

extension ComputeNodeGraph.SwizzleChannels : Codable {

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws
}

extension ComputeNodeGraph.SwizzleChannels.Swizzle : Equatable {
}

extension ComputeNodeGraph.SwizzleChannels.Swizzle : Hashable {
}

extension ComputeNodeGraph.SwizzleChannels.Swizzle : RawRepresentable {
}

extension ComputeNodeGraph.Topology : Equatable {
}

extension ComputeNodeGraph.Topology : Hashable {
}

extension ComputeNodeGraph.Topology : RawRepresentable {
}

public enum CoordinateSpace : String, CaseIterable, Sendable, Codable {

    /// Positions and orientations are stored in relative to the Entity
    case local

    /// Positions and orientations are stored in relative to the Scene.
    ///
    /// Useful for attaching world-space particles to Entities, for effects like
    /// smoke trails.
    case world

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [CoordinateSpace]

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [CoordinateSpace] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: String { get }
}

extension CoordinateSpace : Equatable {
}

extension CoordinateSpace : Hashable {
}

extension CoordinateSpace : RawRepresentable {
}

public enum ElementGrouping : String, CaseIterable, Sendable, Codable {

    case ungrouped

    case strips

    case grouped

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [ElementGrouping]

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [ElementGrouping] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: String { get }
}

extension ElementGrouping : Equatable {
}

extension ElementGrouping : Hashable {
}

extension ElementGrouping : RawRepresentable {
}

public struct ElementSpawnParameters : Sendable {

    /// The initial 3D position of the particle in world space coordinates.
    ///
    /// This determines where the particle will first appear when spawned. The coordinate system
    /// follows RealityKit's conventions with Y pointing up.
    public var position: SIMD3<Float>

    /// The initial velocity vector of the particle in world space units per second.
    ///
    /// This determines the particle's initial direction and speed of movement. The magnitude
    /// of the vector represents the speed, while the direction represents the movement direction.
    /// A zero velocity means the particle starts stationary.
    public var velocity: SIMD3<Float>

    /// The initial size of the particle as a 2D vector representing width and height.
    ///
    /// For most particle systems, this represents the billboard size in world space units.
    /// - `x` component: width of the particle
    /// - `y` component: height of the particle
    ///
    /// Equal values create square particles, while different values create rectangular particles.
    public var size: SIMD2<Float>

    /// The initial color and alpha (transparency) of the particle.
    ///
    /// Uses RGBA format where each component ranges from 0.0 to 1.0:
    /// - `x` (red): Red color component
    /// - `y` (green): Green color component
    /// - `z` (blue): Blue color component
    /// - `w` (alpha): Transparency (0.0 = fully transparent, 1.0 = fully opaque)
    public var color: SIMD4<Float>

    /// The initial lifetime of the particle in seconds.
    ///
    /// This determines how long the particle will exist before being automatically removed
    /// from the simulation. A value of 0 or negative means the particle will be removed
    /// immediately or never spawn.
    public var lifetime: Float

    /// Creates a new set of particle spawn parameters.
    ///
    /// - Parameters:
    ///   - position: The initial 3D position in world space coordinates
    ///   - velocity: The initial velocity vector in world space units per second (defaults to zero)
    ///   - size: The initial size as width and height in world space units (defaults to 0.01 x 0.01)
    ///   - color: The initial RGBA color (defaults to opaque white)
    ///   - lifetime: The particle lifetime in seconds (defaults to 1.0 second)
    ///
    /// ## Example
    /// ```swift
    /// // Create a particle that starts at the origin, moves upward, is red, and lasts 3 seconds
    /// let params = ElementSpawnParameters(
    ///     position: SIMD3<Float>(0, 0, 0),
    ///     velocity: SIMD3<Float>(0, 2, 0),
    ///     size: SIMD2<Float>(0.05, 0.05),
    ///     color: SIMD4<Float>(1, 0, 0, 1),
    ///     lifetime: 3.0
    /// )
    /// ```
    public init(position: SIMD3<Float>, velocity: SIMD3<Float> = .zero, size: SIMD2<Float> = .init(0.01, 0.01), color: SIMD4<Float> = .init(1, 1, 1, 1), lifetime: Float = 1.0)
}

public struct PortReference : Equatable, Sendable, Codable {

    public var group: Int

    public var port: Int

    public init(group: Int, port: Int)

    /// 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: PortReference, b: PortReference) -> Bool

    /// Encodes this value into the given encoder.
    ///
    /// If the value fails to encode anything, `encoder` will encode an empty
    /// keyed container in its place.
    ///
    /// This function throws an error if any values are invalid for the given
    /// encoder's format.
    ///
    /// - Parameter encoder: The encoder to write data to.
    public func encode(to encoder: any Encoder) throws

    /// Creates a new instance by decoding from the given decoder.
    ///
    /// This initializer throws an error if reading from the decoder fails, or
    /// if the data read is corrupted or otherwise invalid.
    ///
    /// - Parameter decoder: The decoder to read data from.
    public init(from decoder: any Decoder) throws
}

public enum Sorting : String, CaseIterable, Sendable {

    case none

    case age

    case timeToLive

    case frontToBack

    case backToFront

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [Sorting]

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [Sorting] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: String { get }
}

extension Sorting : Codable {
}

extension Sorting : Equatable {
}

extension Sorting : Hashable {
}

extension Sorting : RawRepresentable {
}

public enum StandardLibraryFunction : String, Codable, CaseIterable, Sendable {

    case clamp

    case mix

    case saturate

    case sign

    case smoothstep

    case step

    case all

    case any

    case isFinite

    case isInfinite

    case isNaN

    case isNormal

    case isOrdered

    case isUnordered

    case not

    case select

    case signbit

    case acos

    case acosh

    case asin

    case asinh

    case atan

    case atan2

    case atanh

    case ceil

    case copySign

    case cos

    case cosh

    case cospi

    case divide

    case exp

    case exp2

    case exp10

    case abs

    case fdim

    case floor

    case fma

    case max

    case max3

Truncated.

extension StandardLibraryFunction : Equatable {
}

extension StandardLibraryFunction : Hashable {
}

extension StandardLibraryFunction : RawRepresentable {
}

public enum StripOrientation : String, Equatable, Sendable, Codable, CaseIterable {

    /// Automatically derive the orientation of the strip via neighbors and
    /// any provided axisY or axisZ values.
    case auto

    /// Derive the strip's orientation from neighboring points and `axisY` float3 parameter
    case deriveFromYAxis

    /// Derive the strip's orientation from neighboring points and `axisZ` float3 parameter
    case deriveFromZAxis

    /// Use the `axisZ` float3 parameter without re-orienting. Derive Y-axis from
    /// neighboring points and `axisZ`.
    case useZAxis

    /// Use strip's frenet frame for orientation
    case frenet

    case planar

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [StripOrientation]

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [StripOrientation] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: String { get }
}

extension StripOrientation : Hashable {
}

extension StripOrientation : RawRepresentable {
}

public enum Topology : String, CaseIterable, Identifiable, Sendable {

    /// The stable identity of the entity associated with this instance.
    public var id: Topology { get }

    case point

    case triangle

    case quad

    case octagon

    case strip

    case instances

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [Topology]

    /// A type representing the stable identity of the entity associated with
    /// an instance.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias ID = Topology

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [Topology] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: String { get }
}

extension Topology : Codable {
}

extension Topology {

    @available(*, deprecated, message: "Use OutputInfo._proto_indices_v1(elementCount:) instead")
    public var indicesPerElement: Int { get }

    @available(*, deprecated, message: "Use OutputInfo._proto_vertices_v1(elementCount:) instead")
    public var verticesPerElement: Int { get }
}

extension Topology : Equatable {
}

extension Topology : Hashable {
}

extension Topology : RawRepresentable {
}

public enum UnaryOperation : String, Codable, CaseIterable, Sendable {

    case negate

    case logicalNot

    case bitwiseNot

    case oneMinus

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [UnaryOperation]

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [UnaryOperation] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: String { get }
}

extension UnaryOperation : Equatable {
}

extension UnaryOperation : Hashable {
}

extension UnaryOperation : RawRepresentable {
}

public struct SimulationRate : Equatable, Sendable {

    public enum Mode : String, Sendable, Codable, CaseIterable {

        /// Simulate once per frame, using RealityKit's current time step
        case variable

        /// Simulate using a fixed number of steps per second.
        ///
        /// This can result in zero, one, or more steps per frame, depending
        /// on the frequency specified and the current framerate.
        case fixedFrequency

        /// Simulate using time delta.
        ///
        /// Similar to fixedFrequency except the timeDelta is in seconds.
        ///
        /// This can result in zero, one, or more steps per frame, depending
        /// on the frequency specified and the current framerate.
        case fixedTime

        /// 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)

        /// A type that can represent a collection of all values of this type.
        @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
        public typealias AllCases = [ComputeGraphSimulation.SimulationRate.Mode]

        /// The raw type that can be used to represent all values of the conforming
        /// type.
        ///
        /// Every distinct value of the conforming type has a corresponding unique
        /// value of the `RawValue` type, but there may be values of the `RawValue`
        /// type that don't have a corresponding value of the conforming type.
        @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
        public typealias RawValue = String

        /// A collection of all values of this type.
        nonisolated public static var allCases: [ComputeGraphSimulation.SimulationRate.Mode] { get }

        /// The corresponding value of the raw type.
        ///
        /// A new instance initialized with `rawValue` will be equivalent to this
        /// instance. For example:
        ///
        ///     enum PaperSize: String {
        ///         case A4, A5, Letter, Legal
        ///     }
        ///
        ///     let selectedSize = PaperSize.Letter
        ///     print(selectedSize.rawValue)
        ///     // Prints "Letter"
        ///
        ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
        ///     // Prints "true"
        public var rawValue: String { get }
    }

    /// The simulation mode that determines how time steps are calculated.
    public var mode: ComputeGraphSimulation.SimulationRate.Mode

    /// The number of simulation steps per second, used when ``mode`` is ``Mode/fixedFrequency``.
    public var frequency: Float

    /// The fixed time interval in seconds between simulation steps, used when ``mode`` is ``Mode/fixedTime``.

Truncated.

public struct ArrayDefinition : Sendable, Equatable {

    public var count: Int

    public var element: ComputeNodeGraph.StateType

    /// 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: ComputeNodeGraph.ArrayDefinition, b: ComputeNodeGraph.ArrayDefinition) -> Bool
}

public struct Assembly : Sendable, Equatable {

    public var uniforms: [ComputeNodeGraph.Port.Address : ComputeNodeGraph.Assembly.Location] { get }

    /// Uniforms that are shared across multiple graphs, keyed by typeName.
    ///
    /// Shared uniforms are stored globally and copied into each simulation's uniform buffer
    /// before GPU execution. Use them for scene-wide values that many simulations read,
    /// such as transform matrices, attractors, or colliders.
    public var sharedUniforms: [String : ComputeNodeGraph.Assembly.UniformBinding] { get }

    /// Uniforms that are named and exposed as parameters of this graph, keyed by name.
    ///
    /// Unlike ``sharedUniforms``, named uniforms are local to this graph and not
    /// shared with other graphs.
    public var namedUniforms: [String : ComputeNodeGraph.Assembly.UniformBinding] { get }

    public var constantBuffers: [ComputeNodeGraph.Assembly.BufferBinding] { get }

    public var deviceBuffers: [ComputeNodeGraph.Assembly.BufferBinding] { get }

    public var textures: [ComputeNodeGraph.Assembly.TextureBinding] { get }

    public var uniformBufferSize: 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: ComputeNodeGraph.Assembly, b: ComputeNodeGraph.Assembly) -> Bool
}

public struct Edge : Sendable, Equatable, Hashable {

    /// Source of the data, event, or execution flow
    ///
    /// Refers to an output port of a node.
    public var source: ComputeNodeGraph.Port.Address

    /// Target of the data, event, or execution flow
    ///
    /// Refers to an input port of a node.
    public var target: ComputeNodeGraph.Port.Address

    public init(source: ComputeNodeGraph.Port.Address, target: ComputeNodeGraph.Port.Address)

    /// 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: ComputeNodeGraph.Edge, b: ComputeNodeGraph.Edge) -> 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 }
}

public struct LibraryReference : Sendable {

    /// The Metal library containing compiled shader functions.
    public var library: any MTLLibrary

    /// The bundle identifier used to scope shader function lookup, or `nil` if
    /// the library does not require one.
    public var bundle: String?

    public init(library: any MTLLibrary, bundle: String? = nil)
}

public struct Metadata : Sendable, Equatable, ExpressibleByDictionaryLiteral {

    public var values: [String : String]

    public init(values: [String : String] = [String: String]())

    /// Creates an instance initialized with the given key-value pairs.
    public init(dictionaryLiteral elements: (String, String)...)

    /// 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: ComputeNodeGraph.Metadata, b: ComputeNodeGraph.Metadata) -> Bool

    /// The key type of a dictionary literal.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias Key = String

    /// The value type of a dictionary literal.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias Value = String
}

public struct Node : Sendable, Equatable {

    /// Type of the node
    public var kind: ComputeNodeGraph.Node.Kind

    /// Optional user-provided label for the node
    public var label: String?

    public var definition: ComputeNodeGraph.NodeDefinition

    /// Uniform values for the node.
    ///
    /// Order of values matches ``NodeDefinition.inputs``
    public var uniforms: [Data?]

    /// Node metadata -- data which is not needed during compilation but might be useful
    /// at edit time.
    public var metadata: ComputeNodeGraph.Metadata?

    /// 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: ComputeNodeGraph.Node, b: ComputeNodeGraph.Node) -> Bool
}

public struct NodeDefinition : Sendable, Equatable {

    /// Name of the NodeDefinition.
    ///
    /// Definitions whose kind is ``ComputeNodeGraph/NodeDefinition/Kind/function``  will match
    /// their MTLFunction via name.
    public var name: String

    public var bundle: String?

    public var inputs: [ComputeNodeGraph.PortDefinition]

    public var outputs: [ComputeNodeGraph.PortDefinition]

    public var kind: ComputeNodeGraph.NodeDefinition.Kind

    public init(name: String, bundle: String? = nil, inputs: [ComputeNodeGraph.PortDefinition] = [], outputs: [ComputeNodeGraph.PortDefinition] = [], kind: ComputeNodeGraph.NodeDefinition.Kind)

    /// 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: ComputeNodeGraph.NodeDefinition, b: ComputeNodeGraph.NodeDefinition) -> Bool
}

public struct Pipelines : Sendable {

    public var options: ComputeNodeGraph.Pipelines.Options { get }

    public var assembly: ComputeNodeGraph.Assembly { get }
}

public struct PipelinesDescriptor : Sendable {

    /// The assembled compute graph layout that defines the graph's buffer, uniform,
    /// and texture configuration.
    public var assembly: ComputeNodeGraph.Assembly

    /// Options controlling pipeline compilation, such as whether debug draw is enabled.
    public var options: ComputeNodeGraph.Pipelines.Options

    /// The Metal libraries that provide shader function implementations for the graph's nodes.
    public var libraries: [ComputeNodeGraph.LibraryReference]

    /// Creates a descriptor configured for the given graph assembly.
    ///
    /// `options` defaults to ``Pipelines/Options/init()`` and `libraries` is empty.
    /// Add shader libraries with ``addLibrary(_:bundle:)`` before compiling.
    ///
    /// - Parameter assembly: The assembled compute graph to compile pipelines for.
    public init(assembly: ComputeNodeGraph.Assembly)
}

public struct PointerDefinition : Sendable, 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 == (a: ComputeNodeGraph.PointerDefinition, b: ComputeNodeGraph.PointerDefinition) -> Bool
}

public enum Port {

    /// A location of a specific port on a node, identified by the node and the port's index.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public struct Address : Sendable, Equatable, Hashable {

        /// The node that owns this port.
        public var node: ComputeNodeGraph.NodeID

        /// The index of the port within the node's input or output list.
        public var index: Int

        public init(node: ComputeNodeGraph.NodeID, index: Int)

        /// 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: ComputeNodeGraph.Port.Address, b: ComputeNodeGraph.Port.Address) -> 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 }
    }

    /// The semantic role of a port, determining what it carries along an edge
    /// and whether the edge imposes execution ordering between its endpoints.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public enum Kind : Sendable, Equatable {

        /// Carries an ambient runtime context handle injected by the graph at
        /// execution time. Destination reads the handle; no ordering effect.
        case context

        /// Carries a typed data value from source to destination. One-way read,
        /// no ordering effect.
        case value

        /// Carries a read/write binding to named external storage (element,
        /// emitter, group, output attribute, threadgroup memory). Type is always
        /// `.state(definition:)`. No ordering effect.
        case state

        /// Carries a typed event payload. Triggers downstream execution per event
        /// AND carries data (e.g. spawn/update/terminate events with element data).
        case event

        /// Execution-ordering edge whose destination is conceptually a consumer
        /// of the source's typed output. No runtime payload is transferred, but
        /// type compatibility is enforced. Used for stage → stage sequencing.
        case flow

        /// Pure "happens-after" edge. No runtime payload, no type lineage, no

Truncated.

public struct PortDefinition : Sendable, Equatable {

    public var name: String

    public var kind: ComputeNodeGraph.Port.Kind

    public var type: ComputeNodeGraph.ValueType

    public var options: ComputeNodeGraph.Port.Options

    public init(name: String, kind: ComputeNodeGraph.Port.Kind, type: ComputeNodeGraph.ValueType, options: ComputeNodeGraph.Port.Options = [])

    /// 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: ComputeNodeGraph.PortDefinition, b: ComputeNodeGraph.PortDefinition) -> Bool
}

public struct SamplerSettings : Equatable, Sendable {

    public var texture: MTLTextureType

    public var address: MTLSamplerAddressMode

    public var filter: MTLSamplerMinMagFilter

    public init(texture: MTLTextureType, address: MTLSamplerAddressMode, filter: MTLSamplerMinMagFilter)

    /// 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: ComputeNodeGraph.SamplerSettings, b: ComputeNodeGraph.SamplerSettings) -> Bool
}

public struct Scope : Sendable, Equatable, Codable {

    public let name: String

    /// 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: ComputeNodeGraph.Scope, b: ComputeNodeGraph.Scope) -> Bool
}

public struct StateDefinition : Sendable, Equatable {

    /// The scope that owns this state. For example, ``ComputeNodeGraph/Scope/element``
    /// stores a value per particle, while ``ComputeNodeGraph/Scope/emitter`` stores
    /// a single value used by the emission stage.
    public var scope: ComputeNodeGraph.Scope

    /// Whether this state is read, written, or both. See ``ComputeNodeGraph/StateDefinition/Options``.
    public var options: ComputeNodeGraph.StateDefinition.Options

    /// The data type of the stored value.
    public var type: ComputeNodeGraph.StateType

    /// 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: ComputeNodeGraph.StateDefinition, b: ComputeNodeGraph.StateDefinition) -> Bool
}

public enum StateType : Sendable, Equatable {

    /// Value is a primitive with the given type
    case dataType(type: MTLDataType)

    /// Value is a fixed number of untyped bytes
    case data(length: Int)

    /// Value is a structure with the given layout
    case structure(typeName: String, layout: ComputeNodeGraph.StructureLayout)

    /// Value is an array with the provided definition
    case array(definition: ComputeNodeGraph.ArrayDefinition)

    /// 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: ComputeNodeGraph.StateType, b: ComputeNodeGraph.StateType) -> Bool
}

public struct StructureDefinition : Sendable, Equatable {

    public var typeName: String

    public var layout: ComputeNodeGraph.StructureLayout

    /// 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: ComputeNodeGraph.StructureDefinition, b: ComputeNodeGraph.StructureDefinition) -> Bool
}

public struct StructureLayout : Equatable, Sendable {

    public var members: [ComputeNodeGraph.StructureLayout.Member]

    public var size: Int

    public var stride: Int

    public init()

    /// 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: ComputeNodeGraph.StructureLayout, b: ComputeNodeGraph.StructureLayout) -> Bool
}

public struct SwizzleChannels : Equatable, Sendable {

    public enum Swizzle : UInt8, Sendable {

        case zero

        case one

        case red

        case green

        case blue

        case alpha

        /// 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: UInt8)

        /// The raw type that can be used to represent all values of the conforming
        /// type.
        ///
        /// Every distinct value of the conforming type has a corresponding unique
        /// value of the `RawValue` type, but there may be values of the `RawValue`
        /// type that don't have a corresponding value of the conforming type.
        @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
        public typealias RawValue = UInt8

        /// The corresponding value of the raw type.
        ///
        /// A new instance initialized with `rawValue` will be equivalent to this
        /// instance. For example:
        ///
        ///     enum PaperSize: String {
        ///         case A4, A5, Letter, Legal
        ///     }
        ///
        ///     let selectedSize = PaperSize.Letter
        ///     print(selectedSize.rawValue)
        ///     // Prints "Letter"
        ///
        ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
        ///     // Prints "true"
        public var rawValue: UInt8 { get }
    }

    public var red: ComputeNodeGraph.SwizzleChannels.Swizzle

    public var green: ComputeNodeGraph.SwizzleChannels.Swizzle

    public var blue: ComputeNodeGraph.SwizzleChannels.Swizzle

    public var alpha: ComputeNodeGraph.SwizzleChannels.Swizzle

    public init(red: ComputeNodeGraph.SwizzleChannels.Swizzle = .red, green: ComputeNodeGraph.SwizzleChannels.Swizzle = .green, blue: ComputeNodeGraph.SwizzleChannels.Swizzle = .blue, alpha: ComputeNodeGraph.SwizzleChannels.Swizzle = .alpha)

    public init()

    /// 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.

Truncated.

public enum Topology : String, CaseIterable, Sendable {

    case point

    case triangle

    case quad

    case octagon

    case strip

    case instances

    /// 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)

    /// A type that can represent a collection of all values of this type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias AllCases = [ComputeNodeGraph.Topology]

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = String

    /// A collection of all values of this type.
    nonisolated public static var allCases: [ComputeNodeGraph.Topology] { get }

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public var rawValue: String { get }
}

public enum Attachment : Sendable, Equatable {

    /// The resource is owned by the graph and shared across all stages.
    case graph

    /// The resource is read by an input port at the given address.
    case input(ComputeNodeGraph.Port.Address)

    /// The resource is produced by an output port at the given address.
    case output(ComputeNodeGraph.Port.Address)

    /// 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: ComputeNodeGraph.Assembly.Attachment, b: ComputeNodeGraph.Assembly.Attachment) -> Bool
}

public struct BufferBinding : Sendable, Equatable {

    /// The attachment point that provides this buffer.
    public var attachment: ComputeNodeGraph.Assembly.Attachment

    /// The element type stored in the buffer, or `nil` if untyped.
    public var type: ComputeNodeGraph.StateType?

    public init(attachment: ComputeNodeGraph.Assembly.Attachment, type: ComputeNodeGraph.StateType? = nil)

    /// 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: ComputeNodeGraph.Assembly.BufferBinding, b: ComputeNodeGraph.Assembly.BufferBinding) -> Bool
}

public enum Location : Sendable, Equatable {

    /// Value is a context type
    case context

    /// Value is located in uniforms. Its value is located at ``offset`` in the uniforms with length ``length``.
    case uniform(offset: Int, length: Int)

    /// Value is a texture with the given index
    case texture(index: Int)

    /// Buffer that's bound separately from other data. Size of buffer is stored at sizeOffset in uniforms
    case buffer(index: Int, sizeOffset: Int)

    /// Value is the output of another node
    case port(node: Int, index: Int)

    /// Value is in the deviceBuffers table at the specified index and offset
    case deviceBuffer(index: Int, offset: Int)

    /// Value is in the constantBuffers table at the specified index and offset
    case constantBuffer(index: Int, offset: Int)

    /// Value is a fixed 64-bit constant
    case constant(value: Int64)

    /// A context-dependent state value.
    ///
    /// Index references into the states table
    case state(index: Int, offset: Int, length: Int)

    /// Attribute which is a default value and should be considered "not bound"
    case unbound

    /// 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: ComputeNodeGraph.Assembly.Location, b: ComputeNodeGraph.Assembly.Location) -> Bool
}

public struct TextureBinding : Sendable, Equatable {

    /// The attachment point that provides this texture.
    public var attachment: ComputeNodeGraph.Assembly.Attachment

    /// The texture type (e.g. `.type2D`, `.typeCube`), or `nil` if unspecified.
    public var type: MTLTextureType?

    public init(attachment: ComputeNodeGraph.Assembly.Attachment, type: MTLTextureType? = nil)

    /// 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: ComputeNodeGraph.Assembly.TextureBinding, b: ComputeNodeGraph.Assembly.TextureBinding) -> Bool
}

public struct UniformBinding : Sendable, Equatable {

    /// The location of this uniform within the uniform buffer.
    public var location: ComputeNodeGraph.Assembly.Location

    /// The data type stored at this location.
    public var type: ComputeNodeGraph.StateType

    public init(location: ComputeNodeGraph.Assembly.Location, type: ComputeNodeGraph.StateType)

    /// 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: ComputeNodeGraph.Assembly.UniformBinding, b: ComputeNodeGraph.Assembly.UniformBinding) -> Bool
}

public enum Kind : Sendable, Equatable {

    /// Node is standalone operation
    case primitive

    /// Node is a sequence of nodes, which have implicit flow dependencies between them.
    case sequence(nodes: [ComputeNodeGraph.NodeID])

    /// Node is a visual grouping of nodes. This can be presented as, for example, a box around
    /// the nodes, indicating that they are related, but without changing their structure.
    case grouping(nodes: [ComputeNodeGraph.NodeID])

    /// 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: ComputeNodeGraph.Node.Kind, b: ComputeNodeGraph.Node.Kind) -> Bool
}

public enum Kind : Sendable, Equatable {

    /// Node refers to a MTLFunction
    case function

    /// Node represents an execution stage in the graph, for example 'simulation'
    /// or 'emission'
    case stage(type: ComputeNodeGraph.Stage)

    /// Node loads stored state into the graph
    case loadState(definition: ComputeNodeGraph.StateDefinition)

    /// Node stores state into the graph.
    case storeState(definition: ComputeNodeGraph.StateDefinition)

    /// Node contains a reference to a field of another stage, containing
    /// the given layout
    case fieldReference(type: ComputeNodeGraph.StateType)

    case textureReference(port: PortReference)

    /// An arithmetic node with one operand of the given data type, performing the specified operation
    case unaryArithmetic(type: MTLDataType, operation: UnaryOperation)

    /// An arithmetic node with two operands of the given type, performing the specified operation
    case binaryArithmetic(a: MTLDataType, b: MTLDataType, operation: BinaryOperation)

    /// A call to a standard library function with the specified data type.
    case standardLibrary(type: MTLDataType, function: StandardLibraryFunction)

    /// A swizzle operation for the given vector data type and channel specification
    case swizzle(type: MTLDataType, channels: ComputeNodeGraph.SwizzleChannels)

    /// A texture sampling operation with specified settings.
    case sampleTexture(ComputeNodeGraph.SamplerSettings)

    /// A node which composes a structure or vector type from its components
    case compose(type: ComputeNodeGraph.StateType)

    /// A node which decomposes a structure or vector type, providing access to individual components
    case decompose(type: ComputeNodeGraph.StateType)

    /// Convert from one primitive MTLDataType to another.
    ///
    /// Equivalent to calling Metal's constructor of `to` with a value of type `from`
    case convert(from: MTLDataType, to: MTLDataType)

    /// Reinterpret one type scalar or vector type as another of the
    /// same number of size and bytes.
    ///
    /// Equivalent to calling Metal's `as_type<>`
    case reinterpret(from: MTLDataType, to: MTLDataType)

    /// Return a uniform value supplied externally.
    ///
    /// If no inputs exist on the node, space for the output will be allocated.
    ///
    /// Constants can be specified on the node, which can contain external configuration.
    case graphInput

    /// A node which contains global constants affecting the graph
    case graphGlobal

    /// 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: ComputeNodeGraph.NodeDefinition.Kind, b: ComputeNodeGraph.NodeDefinition.Kind) -> Bool
}

public struct Options : Equatable, Sendable {

    /// Whether debug draw should be included in pipelines.
    ///
    /// Debug Draw is disabled by default and its code is removed from
    /// shaders for optimal performance.
    public var debugDraw: Bool

    public init()

    public init(debugDraw: Bool = false)

    /// 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: ComputeNodeGraph.Pipelines.Options, b: ComputeNodeGraph.Pipelines.Options) -> Bool
}

public struct Address : Sendable, Equatable, Hashable {

    /// The node that owns this port.
    public var node: ComputeNodeGraph.NodeID

    /// The index of the port within the node's input or output list.
    public var index: Int

    public init(node: ComputeNodeGraph.NodeID, index: Int)

    /// 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: ComputeNodeGraph.Port.Address, b: ComputeNodeGraph.Port.Address) -> 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 }
}

public enum Kind : Sendable, Equatable {

    /// Carries an ambient runtime context handle injected by the graph at
    /// execution time. Destination reads the handle; no ordering effect.
    case context

    /// Carries a typed data value from source to destination. One-way read,
    /// no ordering effect.
    case value

    /// Carries a read/write binding to named external storage (element,
    /// emitter, group, output attribute, threadgroup memory). Type is always
    /// `.state(definition:)`. No ordering effect.
    case state

    /// Carries a typed event payload. Triggers downstream execution per event
    /// AND carries data (e.g. spawn/update/terminate events with element data).
    case event

    /// Execution-ordering edge whose destination is conceptually a consumer
    /// of the source's typed output. No runtime payload is transferred, but
    /// type compatibility is enforced. Used for stage → stage sequencing.
    case flow

    /// Pure "happens-after" edge. No runtime payload, no type lineage, no
    /// type compatibility check. The destination is ordered after the source
    /// but does not consume its output. Use this to splice a node (e.g. a
    /// compute stage) into execution order between two unrelated nodes.
    case dependency

    /// 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: ComputeNodeGraph.Port.Kind, b: ComputeNodeGraph.Port.Kind) -> 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 }
}

public struct Options : OptionSet, Sendable, Equatable {

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public let rawValue: UInt

    /// Creates a new option set from the given raw value.
    ///
    /// This initializer always succeeds, even if the value passed as `rawValue`
    /// exceeds the static properties declared as part of the option set. This
    /// example creates an instance of `ShippingOptions` with a raw value beyond
    /// the highest element, with a bit mask that effectively contains all the
    /// declared static members.
    ///
    ///     let extraOptions = ShippingOptions(rawValue: 255)
    ///     print(extraOptions.isStrictSuperset(of: .all))
    ///     // Prints "true"
    ///
    /// - Parameter rawValue: The raw value of the option set to create. Each bit
    ///   of `rawValue` potentially represents an element of the option set,
    ///   though raw values may include bits that are not defined as distinct
    ///   values of the `OptionSet` type.
    public init(rawValue: UInt)

    /// Port affects compilation.
    ///
    /// Changes to ``compile`` values require recompiling the pipeline
    public static let compile: ComputeNodeGraph.Port.Options

    /// Port is constant and doesn't need to be changeable.
    ///
    /// Parameters with ``constant`` that are available at compile time can aid in optimization.
    public static let constant: ComputeNodeGraph.Port.Options

    /// Port is an argument to a runtime function.
    ///
    /// These correspond to a function parameter.
    public static let argument: ComputeNodeGraph.Port.Options

    /// The value of this port is optional (may be nil)
    public static let optional: ComputeNodeGraph.Port.Options

    /// The port references a value outside of the graph, such as by filename
    public static let externalReference: ComputeNodeGraph.Port.Options

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

    /// The element type of the option set.
    ///
    /// To inherit all the default implementations from the `OptionSet` protocol,
    /// the `Element` type must be `Self`, the default.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias Element = ComputeNodeGraph.Port.Options

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = UInt
}

public struct Options : OptionSet, Sendable, Equatable {

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public let rawValue: UInt

    /// Creates a new option set from the given raw value.
    ///
    /// This initializer always succeeds, even if the value passed as `rawValue`
    /// exceeds the static properties declared as part of the option set. This
    /// example creates an instance of `ShippingOptions` with a raw value beyond
    /// the highest element, with a bit mask that effectively contains all the
    /// declared static members.
    ///
    ///     let extraOptions = ShippingOptions(rawValue: 255)
    ///     print(extraOptions.isStrictSuperset(of: .all))
    ///     // Prints "true"
    ///
    /// - Parameter rawValue: The raw value of the option set to create. Each bit
    ///   of `rawValue` potentially represents an element of the option set,
    ///   though raw values may include bits that are not defined as distinct
    ///   values of the `OptionSet` type.
    public init(rawValue: UInt)

    /// This port indicates that it is reading from its state.
    public static let read: ComputeNodeGraph.StateDefinition.Options

    /// This port indicates that is writing to the state.
    public static let write: ComputeNodeGraph.StateDefinition.Options

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

    /// The element type of the option set.
    ///
    /// To inherit all the default implementations from the `OptionSet` protocol,
    /// the `Element` type must be `Self`, the default.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias Element = ComputeNodeGraph.StateDefinition.Options

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
    public typealias RawValue = UInt
}

public struct Member : Equatable, Sendable {

    /// Name of this member in the containing structure
    public var name: String

    /// Offset, in bytes, of this member in its containing structure
    public var offset: Int

    public var type: ComputeNodeGraph.StateType

    /// 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: ComputeNodeGraph.StructureLayout.Member, b: ComputeNodeGraph.StructureLayout.Member) -> Bool
}