What's new in CoreVideo

extension Array : CVAttachmentValueRepresentable where Element : CVAttachmentValueRepresentable {

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> [Element]?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }
}

extension Bool : CVAttachmentValueRepresentable {
}

extension CGColorSpace : CVAttachmentValueRepresentable {
}

extension CGFloat : CVAttachmentValueRepresentable {
}

extension CGRect : CVAttachmentValueRepresentable {

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CGRect?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }
}

extension CGSize : CVAttachmentValueRepresentable {

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CGSize?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }
}

@dynamicMemberLookup public struct CVAttachmentAccess<Keys> : ~Escapable, ~Copyable where Keys : CVAttachmentKeyDefinitions {

    /// Get or set attachment value as a property of this object.
    ///
    /// This subscript provides access to an attachment key as a property. The key to be accessed must be defined as a
    /// static property on the ``Keys`` type.
    ///
    /// ```swift
    /// extension CVPixelBufferAttachmentKeyDefinitions {
    /// 	static var pixelBufferNumber: Key<ShouldPropagate, Int> {
    /// 		"com.app.pixelBufferNumber"
    /// 	}
    /// }
    ///
    /// func inspect(attachments: borrowing CVAttachmentAccess<CVPixelBufferAttachmentKeyDefinitions>) {
    /// 	let value: Int? = attachments.pixelBufferNumber
    /// }
    /// ```
    public subscript<ModePreference, Value>(dynamicMember keyPath: KeyPath<Keys.Type, CVAttachmentKeyDefinition<ModePreference, Value>>) -> Value? where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable

    /// Get or set attachment value as a property of this object with default value.
    ///
    /// This subscript provides access to an attachment key as a property. The key to be accessed must be defined as a
    /// static property on the ``Keys`` type.
    ///
    /// ```swift
    /// extension CVPixelBufferAttachmentKeyDefinitions {
    /// 	static var isSpecialPicture: KeyWithDefault<ShouldPropagate, Bool> {
    /// 		.init("com.app.isSpecialPicture", default: false)
    /// 	}
    /// }
    ///
    /// func inspect(attachments: borrowing CVAttachmentAccess<CVPixelBufferAttachmentKeyDefinitions>) {
    /// 	if attachments.isSpecialPicture {
    /// 		...
    /// 	}
    /// }
    /// ```
    public subscript<ModePreference, Value>(dynamicMember keyPath: KeyPath<Keys.Type, CVAttachmentKeyDefinitionWithDefault<ModePreference, Value>>) -> Value where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable, Value : Equatable, Value : Sendable

    /// Get or set composite attachment value as a property of this object.
    ///
    /// This subscript provides access to an attachment key as a property. The key to be accessed must be defined as a
    /// static property on the ``Keys`` type. This accessor is intended to be used with legacy keys which are not grouped
    /// together in a single container. For new keys, use ``CVAttachmentKeyDefinitions/Key`` instead of using a composite
    /// key group.
    ///
    /// ```swift
    /// enum MyImageTag: CVAttachmentValueRepresentable {
    /// 	case int(Int)
    /// 	case string(String)
    ///
    /// 	static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> Self? {
    /// 		guard let kind: String = repr["com.app.MyImageTag.Kind"] else { return nil }
    /// 		switch kind {
    /// 		case "int":
    /// 			guard let value: Int = repr["com.app.MyImageTag.Value"] else { return nil }
    /// 			return .int(value)
    /// 		case "str":
    /// 			guard let value: String = repr["com.app.MyImageTag.Value"] else { return nil }
    /// 			return .string(value)
    /// 		default:
    /// 			return nil
    /// 		}
    /// 	}
    ///
    /// 	var rawAttachmentValueRepresentation: CVAttachmentRawValue {
    /// 		switch self {
    /// 		case .int(let value):
    /// 			[
    /// 				"com.app.MyImageTag.Kind": "int",
    /// 				"com.app.MyImageTag.Value": value,
    /// 			]
    /// 		case .string(let value):
    /// 			[
    /// 				"com.app.MyImageTag.Kind": "str",
    /// 				"com.app.MyImageTag.Value": value,
    /// 			]
    /// 		}
    /// 	}

Truncated.

public struct CVAttachmentCompositeKeyDefinition<ModePreference, Value> : Hashable, Sendable, ExpressibleByArrayLiteral where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable {

    public var rawValues: [String]

    public init(_ rawValues: String...)

    /// Creates an instance initialized with the given elements.
    public init(arrayLiteral rawValues: 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: CVAttachmentCompositeKeyDefinition<ModePreference, Value>, b: CVAttachmentCompositeKeyDefinition<ModePreference, Value>) -> Bool

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

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

@dynamicMemberLookup public struct CVAttachmentContainer<Keys> : Sendable, Equatable where Keys : CVAttachmentKeyDefinitions {

    public init(propagated: [String : any CVAttachmentValueRepresentable] = [:], nonPropagated: [String : any CVAttachmentValueRepresentable] = [:])

    /// Get or set attachment value as a property of this object.
    public subscript<ModePreference, Value>(dynamicMember keyPath: KeyPath<Keys.Type, CVAttachmentKeyDefinition<ModePreference, Value>>) -> Value? where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable

    /// Get or set attachment value as a property of this object with default value.
    public subscript<ModePreference, Value>(dynamicMember keyPath: KeyPath<Keys.Type, CVAttachmentKeyDefinitionWithDefault<ModePreference, Value>>) -> Value where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable, Value : Equatable, Value : Sendable

    /// Get or set composite attachment value as a property of this object.
    public subscript<ModePreference, Value>(dynamicMember keyPath: KeyPath<Keys.Type, CVAttachmentCompositeKeyDefinition<ModePreference, Value>>) -> Value? where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable

    /// Get or set attachment value associated with a string key
    public subscript<Value>(rawKey: String, as type: Value.Type = Value.self) -> (value: Value, mode: CVAttachmentMode)? where Value : CVAttachmentValueRepresentable

    /// Updates propagated and non-propagated attachment values using the provided container.
    public mutating func update(from other: CVAttachmentContainer<Keys>)

    /// Removes all attachments.
    public mutating func removeAll()

    /// Returns mode of an attached key without retriving value.
    ///
    /// This function can be used to check for the presence of a specific key without converting it's value.
    /// Returns `nil` if the key is not attached.
    public func attachedMode(of key: String) -> CVAttachmentMode?

    /// Returns mode of an attached key without retriving value.
    ///
    /// This function can be used to check for the presence of a specific key without converting it's value.
    /// Returns `nil` if the key is not attached.
    public func attachedMode(of keyPath: KeyPath<Keys.Type, CVAttachmentKeyDefinition<some CVAttachmentModePreference, some CVAttachmentValueRepresentable>>) -> CVAttachmentMode?

    /// Returns mode of an attached key without retriving value.
    ///
    /// This function can be used to check for the presence of a specific key without converting it's value.
    /// Returns `nil` if the key is not attached.
    public func attachedMode(of keyPath: KeyPath<Keys.Type, CVAttachmentKeyDefinitionWithDefault<some CVAttachmentModePreference, some CVAttachmentValueRepresentable & Equatable & Sendable>>) -> CVAttachmentMode?

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

public struct CVAttachmentKeyDefinition<ModePreference, Value> : Hashable, Sendable, ExpressibleByStringLiteral where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable {

    public var rawValue: String

    public init(_ rawValue: String)

    /// Creates an instance initialized to the given string value.
    ///
    /// - Parameter value: The value of the new instance.
    public init(stringLiteral rawValue: 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: CVAttachmentKeyDefinition<ModePreference, Value>, b: CVAttachmentKeyDefinition<ModePreference, Value>) -> Bool

    /// 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, watchOS 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, watchOS 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, watchOS 27.0, *)
    public typealias UnicodeScalarLiteralType = String

    /// 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 protocol CVAttachmentKeyDefinitions {

    typealias ShouldPropagate = CVAttachmentModePreferenceShouldPropagate

    typealias ShouldNotPropagate = CVAttachmentModePreferenceShouldNotPropagate

    typealias Key = CVAttachmentKeyDefinition

    typealias KeyWithDefault = CVAttachmentKeyDefinitionWithDefault

    typealias CompositeKey = CVAttachmentCompositeKeyDefinition
}

public struct CVAttachmentKeyDefinitionWithDefault<ModePreference, Value> : Sendable, Equatable where ModePreference : CVAttachmentModePreference, Value : CVAttachmentValueRepresentable, Value : Equatable, Value : Sendable {

    public var rawValue: String

    public var defaultValue: Value

    public init(_ rawValue: String, default defaultValue: Value)

    /// 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: CVAttachmentKeyDefinitionWithDefault<ModePreference, Value>, b: CVAttachmentKeyDefinitionWithDefault<ModePreference, Value>) -> Bool
}

extension CVAttachmentKeyDefinitionWithDefault : Hashable where Value : 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 }
}

public protocol CVAttachmentModePreference : Sendable {

    @inlinable static var preferredMode: CVAttachmentMode { get }
}

public enum CVAttachmentModePreferenceShouldNotPropagate : CVAttachmentModePreference {

    @inlinable public static var preferredMode: CVAttachmentMode { get }
}

public enum CVAttachmentModePreferenceShouldPropagate : CVAttachmentModePreference {

    @inlinable public static var preferredMode: CVAttachmentMode { get }
}

public struct CVAttachmentRawValue : Equatable, ExpressibleByDictionaryLiteral {

    /// Creates an empty raw attachment value.
    public init()

    /// Creates raw attachment value from dictionary literal.
    public init(dictionaryLiteral elements: (String, (any CVAttachmentValueRepresentable)?)...)

    /// Get or set value associated with the specified key.
    public subscript<Value>(key: String, as type: Value.Type = Value.self) -> Value? where Value : CVAttachmentValueRepresentable

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

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

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

public protocol CVAttachmentValueRepresentable {

    static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> Self?

    var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }
}

public enum CVImageAlphaChannelMode : String, Sendable, Hashable, CVAttachmentValueRepresentable {

    case straightAlpha

    case premultipliedAlpha

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

    /// 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 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, watchOS 27.0, *)
    public typealias RawValue = String
}

extension CVImageAlphaChannelMode : RawRepresentable {
}

public protocol CVImageBufferAttachmentKeyDefinitions : CVAttachmentKeyDefinitions {
}

extension CVImageBufferAttachmentKeyDefinitions {

    /// Color space of the image buffer.
    @inlinable public static var colorSpace: CVAttachmentKeyDefinition<Self.ShouldPropagate, CGColorSpace> { get }

    /// Clean aperture of the image buffer.
    @inlinable public static var cleanAperture: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageCleanAperture> { get }

    /// The order of interlaced video data in the image buffer.
    @inlinable public static var fieldDetail: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageFieldDetail> { get }

    /// Pixel aspect ratio for the image buffer.
    @inlinable public static var pixelAspectRatio: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImagePixelAspectRatio> { get }

    /// Display dimensions for the image buffer.
    @inlinable public static var displayDimensions: CVAttachmentKeyDefinition<Self.ShouldPropagate, CGSize> { get }

    /// The gamma level for the image buffer.
    @inlinable public static var gammaLevel: CVAttachmentKeyDefinition<Self.ShouldPropagate, Double> { get }

    /// ICC color profile for the image buffer.
    @inlinable public static var iccProfile: CVAttachmentKeyDefinition<Self.ShouldPropagate, Data> { get }

    /// The matrix to convert from YCbCr to the RGB color space.
    @inlinable public static var yCbCrMatrix: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageYCbCrMatrix> { get }

    /// The color primaries gamut for the image buffer.
    @inlinable public static var colorPrimaries: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageColorPrimaries> { get }

    /// The transfer characteristic for the image buffer.
    @inlinable public static var transferFunction: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageTransferFunction> { get }

    /// The chroma field information for the image buffer.
    @inlinable public static var chromaField: CVAttachmentCompositeKeyDefinition<Self.ShouldPropagate, CVImageChromaField> { get }

    /// True if the alpha channel in the image data is fully opaque.
    ///
    /// This key is not used if the pixel format type has no alpha channel.
    @inlinable public static var alphaChannelIsOpaque: CVAttachmentKeyDefinition<Self.ShouldPropagate, Bool> { get }

    /// Determines how the alpha channel should be rendered.
    public static var alphaChannelMode: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageAlphaChannelMode> { get }

    /// Mastering display color volume of the image.
    ///
    /// The value for this key is a 44 byte big-endian data sequence to match the payload of ISO/IEC 23008-2:2015(E),
    /// D.2.28 mastering display color volume in the supplemental enhancement information (SEI) message.
    @inlinable public static var masteringDisplayColorVolume: CVAttachmentKeyDefinition<Self.ShouldPropagate, Data> { get }

    /// The content light level information for the image.
    ///
    /// The value for this key is a 4 byte big-endian data sequence to match the payload of the content light level
    /// information metadata in the supplemental enhancement information (SEI) message.
    @inlinable public static var contentLightLevelInfo: CVAttachmentKeyDefinition<Self.ShouldPropagate, Data> { get }

    /// The ambient viewing environment for the image.
    /// The value for this key is an 8 byte big-endian data sequence to match the payload of the Ambient Viewing Environment SEI message.
    @inlinable public static var ambientViewingEnvironment: CVAttachmentKeyDefinition<Self.ShouldPropagate, Data> { get }

    /// Scene illumination measured in millilux.
    @inlinable public static var sceneIllumination: CVAttachmentKeyDefinition<Self.ShouldPropagate, Int> { get }

    /// Specifies region of interest that image statistics cover.
    @inlinable public static var regionOfInterest: CVAttachmentKeyDefinition<Self.ShouldPropagate, CGRect> { get }

    /// Indicates that the transfer function or gamma of the content is a log format and identifies the specific log curve.
    @inlinable public static var logTransferFunction: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageLogTransferFunction> { get }

    /// Specifies the rectangular display area within the image.
    @inlinable public static var displayMaskRectangle: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageDisplayMaskRectangle> { get }

    /// Specifies the rectangular display area within the left eye view of stereo images.
    @inlinable public static var leftStereoDisplayMaskRectangle: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageStereoDisplayMaskRectangle> { get }

    /// Specifies the rectangular display area within the right eye view of stereo images.
    @inlinable public static var rightStereoDisplayMaskRectangle: CVAttachmentKeyDefinition<Self.ShouldPropagate, CVImageStereoDisplayMaskRectangle> { get }

    /// Indicates a relative shift of the left and right images, which changes the zero parallax plane.
    ///
    /// The value encoded in normalized image space is measured over the range of -10000 to 10000 mapping to the uniform

Truncated.

public struct CVImageChromaField : Sendable, CVAttachmentValueRepresentable {

    /// Indicates the locations of the chroma sample in the image buffer.
    public enum SampleLocation : String, Sendable, Hashable, CVAttachmentValueRepresentable {

        /// Chroma sample is horizontally co-sited with the left column of luma samples, but centered vertically.
        case left

        /// Chroma sample is fully centered.
        case center

        /// Chroma sample is co-sited with the top-left luma sample.
        case topLeft

        /// Chroma sample is horizontally centered, but is co-sited with the top row of luma samples.
        case top

        /// Chroma sample is co-sited with the bottom-left luma sample.
        case bottomLeft

        /// Chroma sample is horizontally centered, but is co-sited with the bottom row of luma samples.
        case bottom

        /// The Cr and Cb samples are alternatingly co-sited with the left luma samples of the same field.
        case dv420

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

        /// 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 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, watchOS 27.0, *)
        public typealias RawValue = String
    }

    /// Indicates chroma sample location for progressive-scan & interlaced image data.
    public enum FieldLocation : Sendable, CVAttachmentValueRepresentable {

        case progressive(CVImageChromaField.SampleLocation)

        case interlaced(top: CVImageChromaField.SampleLocation, bottom: CVImageChromaField.SampleLocation)

        public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CVImageChromaField.FieldLocation?

Truncated.

extension CVImageChromaField.ChromaSubsampling : RawRepresentable {
}

extension CVImageChromaField.SampleLocation : RawRepresentable {
}

@frozen public struct CVImageCleanAperture : Sendable, Hashable, CVAttachmentValueRepresentable {

    /// Width of the clean aperture.
    public var width: Float

    /// Height of the clean aperture.
    public var height: Float

    /// Horizontal offset from the center of the image buffer.
    ///
    /// A positive value of this property will move the center of clean aperture towards right side.
    public var horizontalOffset: Float

    /// Vertical offset from the center of the image buffer.
    ///
    /// A positive value of this property will move the center of clean aperture downwards.
    public var verticalOffset: Float

    public init(width: Float, height: Float, horizontalOffset: Float, verticalOffset: Float)

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CVImageCleanAperture?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { 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: CVImageCleanAperture, b: CVImageCleanAperture) -> 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 CVImageCleanAperture : BitwiseCopyable {
}

public enum CVImageColorPrimaries : String, Sendable, Hashable, CVAttachmentValueRepresentable {

    /// Color primaries gamut for HD video.
    case itu_R_709_2

    /// Color primaries gamut for PAL video.
    case ebu_3213

    /// Color primaries gamut for standard-definition video.
    case smpte_C

    /// Color primaries gamut for sRGB video.
    case p22

    /// Color primaries gamut for DCI P3 theatrical distribution video.
    case dci_P3

    /// Color primaries gamut for DCI P3 video with D65 white point.
    case p3_D65

    /// Color primaries gamut for ITU-R BT2020 HDR video.
    case itu_R_2020

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

    /// 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 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, watchOS 27.0, *)
    public typealias RawValue = String
}

extension CVImageColorPrimaries : RawRepresentable {
}

public struct CVImageDisplayMaskRectangle : Sendable, Hashable, CVAttachmentValueRepresentable {

    /// The horizontal pixel offset of the rectangle from the left of the bounding raster.
    ///
    /// This value is always less than ``referenceRasterWidth``.
    public var left: UInt16

    /// The vertical pixel offset of the rectangle from the top of the bounding raster.
    ///
    /// This value is always less than ``referenceRasterHeight``.
    public var top: UInt16

    /// The width of the rectangle starting at rectangle's left offset toward the rectangle's right edge.
    ///
    /// This value is always less than ``referenceRasterWidth``.
    public var width: UInt16

    /// The height of the rectangle starting at rectangle's top offset toward the rectangle's bottom edge.
    ///
    /// This value is always less than ``referenceRasterHeight``.
    public var height: UInt16

    /// The width in pixels of the 2D coordinate system to define the rectangle.
    ///
    /// Usually matches the width of the video or the output device.
    public var referenceRasterWidth: UInt16

    /// Specifies the height in pixels of the 2D coordinate system to define the rectangle.
    ///
    /// Usually matches the height of the video or the output device.
    public var referenceRasterHeight: UInt16

    public init(left: UInt16, top: UInt16, width: UInt16, height: UInt16, referenceRasterWidth: UInt16, referenceRasterHeight: UInt16)

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CVImageDisplayMaskRectangle?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { 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: CVImageDisplayMaskRectangle, b: CVImageDisplayMaskRectangle) -> 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 CVImageFieldDetail : String, Sendable, Hashable, CVAttachmentValueRepresentable {

    /// The image buffer contains complete fields in alternating order. The top, odd-numbered, fields contain image
    /// data captured at an earlier time than bottom, even-numbered, fields.
    case temporalTopFirst

    /// The image buffer contains complete fields in alternating order. The bottom, even-numbered, fields contain image
    /// data captured at an earlier time than top, odd-numbered, fields.
    case temporalBottomFirst

    /// The image buffer contains interleaved fields. The first line of image data corresponds to the first top,
    /// odd-numbered, field.
    case spatialFirstLineEarly

    /// The image buffer contains interleaved fields. The first line of image data corresponds to the first bottom,
    /// even-numbered, field.
    case spatialFirstLineLate

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

    /// 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 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, watchOS 27.0, *)
    public typealias RawValue = String
}

extension CVImageFieldDetail : RawRepresentable {
}

public enum CVImageLogTransferFunction : String, Sendable, Hashable, CVAttachmentValueRepresentable {

    /// Apple log profile.
    case appleLog

    /// Apple log 2 profile.
    case appleLog2

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

    /// 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 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, watchOS 27.0, *)
    public typealias RawValue = String
}

extension CVImageLogTransferFunction : RawRepresentable {
}

@frozen public struct CVImagePixelAspectRatio : Sendable, Hashable, CVAttachmentValueRepresentable {

    /// The horizontal component of the image buffer aspect ratio.
    public var horizontalSpacing: Float

    /// The vertical component of the image buffer aspect ratio.
    public var verticalSpacing: Float

    public init(horizontalSpacing: Float, verticalSpacing: Float)

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CVImagePixelAspectRatio?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { 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: CVImagePixelAspectRatio, b: CVImagePixelAspectRatio) -> 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 CVImagePixelAspectRatio : BitwiseCopyable {
}

public struct CVImageStereoDisplayMaskRectangle : Sendable, Hashable, CVAttachmentValueRepresentable {

    /// Specifies inset point on a vertical edge of the rectangle.
    public struct EdgePoint : Sendable, Hashable {

        /// Offset from left edge (0) towards the right edge (width).
        public var x: UInt16

        /// Offset from top edge (0) towards the bottom edge (height).
        public var y: UInt16

        public init(x: UInt16, y: UInt16)

        /// 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: CVImageStereoDisplayMaskRectangle.EdgePoint, b: CVImageStereoDisplayMaskRectangle.EdgePoint) -> 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 }
    }

    /// Rectangular display area within the image.
    public var maskRectangle: CVImageDisplayMaskRectangle

    /// Inset points on the left edge of the rectangle.
    public var leftEdgePoints: [CVImageStereoDisplayMaskRectangle.EdgePoint]

    /// Inset points on the right edge of the rectangle.
    public var rightEdgePoints: [CVImageStereoDisplayMaskRectangle.EdgePoint]

    public init(maskRectangle: CVImageDisplayMaskRectangle, leftEdgePoints: [CVImageStereoDisplayMaskRectangle.EdgePoint], rightEdgePoints: [CVImageStereoDisplayMaskRectangle.EdgePoint])

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CVImageStereoDisplayMaskRectangle?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { 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: CVImageStereoDisplayMaskRectangle, b: CVImageStereoDisplayMaskRectangle) -> 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

Truncated.

public enum CVImageTransferFunction : String, Sendable, Hashable, CVAttachmentValueRepresentable {

    case linear

    /// The standard transfer function for web and desktop publishing.
    case sRGB

    /// The transfer function that’s defined by the gamma level value of the image buffer.
    case useGamma

    /// The transfer function for HDTV interim video.
    case smpte_240M_1995

    /// The transfer function for digital cinema distribution master.
    case smpte_ST_428_1

    /// The transfer function for mapping HDR gamma to absolute light levels.
    case smpte_ST_2084_PQ

    /// The default transfer function for high-definition and standard-definition video.
    case itu_R_709_2

    /// The transfer function for HDR video specified in ITU-R BT2020 standard.
    case itu_R_2020

    /// The transfer function for HDR video specified in ITU-R BT2020 HLG standard.
    case itu_R_2100_HLG

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

    /// 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 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, watchOS 27.0, *)
    public typealias RawValue = String
}

extension CVImageTransferFunction : RawRepresentable {
}

public enum CVImageYCbCrMatrix : String, Sendable, Hashable, CVAttachmentValueRepresentable {

    /// The conversion matrix for 1920 x 1135 HDTV images, that follows the SMPTE 240M 1995 standard.
    case smpte_240M_1995

    /// The conversion matrix for HDTV digital television images, that follows the ITU R 709 standard.
    case itu_R_709_2

    /// The conversion matrix for standard definition television images, that follows the ITU R 601 standard.
    case itu_R_601_4

    /// The conversion matrix for UHDTV digital television images, that follows the ITU Rec 2020 standard.
    case itu_R_2020

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

    /// 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 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, watchOS 27.0, *)
    public typealias RawValue = String
}

extension CVImageYCbCrMatrix : RawRepresentable {
}

extension CVMutablePixelBuffer {

    /// Access attachments of this pixel buffer.
    public var attachments: CVMutablePixelBuffer.Attachments
}

public enum CVPixelBufferAttachmentKeyDefinitions : CVImageBufferAttachmentKeyDefinitions {

    /// Bayer pattern indicating sensel arrangement.
    ///
    /// This attachment applies only to buffers with VersatileBayer formats.
    public static let senselArrayPattern: CVAttachmentKeyDefinition<CVPixelBufferAttachmentKeyDefinitions.ShouldNotPropagate, CVSenselArrayPattern>

    /// ProRes RAW image metadata used for raw conversion.
    public static let proResRawMetadata: CVAttachmentCompositeKeyDefinition<CVPixelBufferAttachmentKeyDefinitions.ShouldPropagate, CVProResRawMetadata>
}

extension CVPixelBufferAttributes {

    /// Attachments to set on the pixel buffer.
    public var attachments: CVAttachmentContainer<CVPixelBufferAttachmentKeyDefinitions>?
}

extension CVPixelBufferRepresentable where Self : ~Copyable {

    public typealias Attachments = CVAttachmentAccess<CVPixelBufferAttachmentKeyDefinitions>

    /// Access attachments of this pixel buffer.
    public var attachments: Self.Attachments { get }
}

public struct CVProResRawMetadata : Sendable, CVAttachmentValueRepresentable {

    /// Siting offsets, relative to pixel center, of individual sensels/components constituting each pixel.
    public var senselSitingOffsets: CVSenselSitingOffsets

    /// The sensel level corresponding to no light exposure.
    public var blackLevel: Int32

    /// The sensel level corresponding to sensor (or camera A-to-D converter) saturation.
    public var whiteLevel: Int32

    /// The illuminant correlated color temperature (CCT), in kelvins, selected at the time of capture. If not present,
    /// the CCT is considered unknown or unspecified.
    public var whiteBalanceCCT: Float32?

    /// The white balance multiplication factor for red-filtered sensels.
    public var whiteBalanceRedFactor: Float32

    /// The white balance multiplication factor for blue-filtered sensels.
    public var whiteBalanceBlueFactor: Float32

    /// This is a 3x3 matrix which transforms linear RGB pixel values in the camera native color space to CIE 1931 XYZ
    /// values relative to the D65 illuminant, where the matrix entries are stored in row-major order.
    public var colorMatrix: InlineArray<9, Float32>

    /// The overall gain factor for raw conversion.
    public var gainFactor: Float32

    /// The recommended number of: pixels to discard from the start (left) of each row of the image; pixels to discard
    /// from the end (right) of each row of the image; rows of pixels to discard from the top of the image; and rows of
    /// pixels to discard from the bottom of the image. Pixels/rows are discarded after raw conversion.
    public var recommendedCrop: CVProResRawMetadata.RecommendedCrop

    /// ProRes RAW metadata extensions.
    /// This Data contains a big-endian UInt32 representing the size of the item in bytes followed by a 4-character code
    /// ('psim') followed by a variable-length pascal string identifying the metadata (like a key string) followed by
    /// the metadata payload.
    public var extensions: Data?

    public init(senselSitingOffsets: CVSenselSitingOffsets = .zero, blackLevel: Int32, whiteLevel: Int32, whiteBalanceCCT: Float32? = nil, whiteBalanceRedFactor: Float32, whiteBalanceBlueFactor: Float32, colorMatrix: InlineArray<9, Float32>, gainFactor: Float32, recommendedCrop: CVProResRawMetadata.RecommendedCrop = .zero, extensions: Data? = nil)

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> CVProResRawMetadata?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }

    /// Recommended pixels to discard in the image after raw conversion.
    ///
    /// The values may be nonintegral due to downscaling, in which case the handling of fractional parts is
    /// implementation-dependent.
    public struct RecommendedCrop : RawRepresentable, Sendable, Hashable, CVAttachmentValueRepresentable {

        /// Pixels to discard from the start (left) of each row of the image.
        public var pixelsToDiscardAtStartOfEachRow: Float32

        /// Pixels to discard from the end (right) of each row of the image.
        public var pixelsToDiscardAtEndOfEachRow: Float32

        /// Rows of pixels to discard from the top of the image.
        public var rowsOfPixelsToDiscardAtTop: Float32

        /// Rows of pixels to discard from the bottom of the image.
        public var rowsOfPixelsToDiscardAtBottom: Float32

        public init(pixelsToDiscardAtStartOfEachRow: Float32, pixelsToDiscardAtEndOfEachRow: Float32, rowsOfPixelsToDiscardAtTop: Float32, rowsOfPixelsToDiscardAtBottom: Float32)

        public static let zero: CVProResRawMetadata.RecommendedCrop

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

Truncated.

public enum CVSenselArrayPattern : Int, Sendable, Hashable, CVAttachmentValueRepresentable {

    /// Top-left sensel of the frame is red-filtered.
    case bayerRGGB

    /// Top-left sensel of the frame is green-filtered, with the top row alternating between green and red-filtered sensels.
    case bayerGRBG

    /// Top-left sensel of the frame is green-filtered, with the top row alternating between green and blue-filtered sensels.
    case bayerGBRG

    /// Top-left sensel of the frame is blue-filtered.
    case bayerBGGR

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

    /// 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, watchOS 27.0, *)
    public typealias RawValue = Int

    /// 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: Int { get }
}

extension CVSenselArrayPattern : RawRepresentable {
}

public struct CVSenselSitingOffsets : RawRepresentable, Sendable, Hashable, CVAttachmentValueRepresentable {

    /// Siting offset of a component, relative to pixel center.
    ///
    /// A positive offset value indicates that the sensel/component lies to the right of or below the center of its pixel,
    /// while a negative value indicates that the sensel/component lies to the left of or above the center of its pixel.
    /// Horizontal and vertical offset magnitudes are respectively in terms of the spacing between horizontally and
    /// vertically-adjacent pixel centers.
    public struct Offset : Sendable, Hashable {

        public var horizontal: Float32

        public var vertical: Float32

        public init(horizontal: Float32, vertical: Float32)

        public static let zero: CVSenselSitingOffsets.Offset

        /// 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: CVSenselSitingOffsets.Offset, b: CVSenselSitingOffsets.Offset) -> 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 var red: CVSenselSitingOffsets.Offset

    public var green: CVSenselSitingOffsets.Offset

    public var blue: CVSenselSitingOffsets.Offset

    public var alpha: CVSenselSitingOffsets.Offset

    public init(red: CVSenselSitingOffsets.Offset, green: CVSenselSitingOffsets.Offset, blue: CVSenselSitingOffsets.Offset, alpha: CVSenselSitingOffsets.Offset)

    public static let zero: CVSenselSitingOffsets

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

Truncated.

extension Data : CVAttachmentValueRepresentable {
}

extension Date : CVAttachmentValueRepresentable {
}

extension Dictionary : CVAttachmentValueRepresentable where Key : CVAttachmentValueRepresentable, Value : CVAttachmentValueRepresentable {

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> [Key : Value]?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }
}

extension Double : CVAttachmentValueRepresentable {
}

extension Float : CVAttachmentValueRepresentable {
}

extension Int : CVAttachmentValueRepresentable {
}

extension Int16 : CVAttachmentValueRepresentable {
}

extension Int32 : CVAttachmentValueRepresentable {
}

extension Int64 : CVAttachmentValueRepresentable {
}

extension Int8 : CVAttachmentValueRepresentable {
}

extension RawRepresentable where Self.RawValue : CVAttachmentValueRepresentable {

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> Self?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }
}

extension Set : CVAttachmentValueRepresentable where Element : CVAttachmentValueRepresentable {

    public static func makeFromRawAttachmentValue(_ repr: CVAttachmentRawValue) -> Set<Element>?

    public var rawAttachmentValueRepresentation: CVAttachmentRawValue { get }
}

extension String : CVAttachmentValueRepresentable {
}

extension UInt : CVAttachmentValueRepresentable {
}

extension UInt16 : CVAttachmentValueRepresentable {
}

extension UInt32 : CVAttachmentValueRepresentable {
}

extension UInt64 : CVAttachmentValueRepresentable {
}

extension UInt8 : CVAttachmentValueRepresentable {
}

extension URL : CVAttachmentValueRepresentable {
}

extension UUID : CVAttachmentValueRepresentable {
}