What's new in Vision

public struct BarcodeObservation : VisionObservation, QuadrilateralProviding {

    public enum CompositeType : Codable, Equatable, Hashable, Sendable {

        /// A type that represents trade items in bulk.
        case gs1TypeA

        /// A type that represents trade items by piece.
        case gs1TypeB

        /// A type that represents trade items in varying quantity.
        case gs1TypeC

        /// A type that represents a linked composite type.
        case linked

        /// 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: BarcodeObservation.CompositeType, b: BarcodeObservation.CompositeType) -> 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
    }

    /// A string value that represents the barcode payload.
    ///
    /// Depending on the symbology or the payload data itself, a string representation of the payload may not be available.
    public let payloadString: String?

    /// The raw data representation of the barcode’s payload.
    public let payloadData: Data?

Truncated.

extension BarcodeObservation : 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
}

public struct BarcodeReaderTool : Tool, @unchecked Sendable {

    /// A unique name for the tool, such as "get_weather", "toggleDarkMode", or "search contacts".
    public let name: String

    /// A natural language description of when and how to use the tool.
    public let description: String

    /// Creates a tool for decoding machine-readable codes.
    ///
    /// - Parameters:
    ///   - name: The name of the tool as exposed to the model. If not provided, a default name is used.
    ///   - description: A description of what the tool does, used by the model to determine when to call it. If not provided, a default description is used.
    public init(name: String? = nil, description: String? = nil)

    /// The arguments that this tool should accept.
    ///
    /// Typically arguments are either a ``Generable`` type or ``GeneratedContent``.
    public struct Arguments {

        /// An instance of the generation schema.
        nonisolated public static var generationSchema: GenerationSchema { get }

        /// This instance represented as generated content.
        ///
        /// Conformance to this protocol is provided by the `@Generable` macro.
        /// A manual implementation may be used to map values onto properties using
        /// different names. Use the generated content property as shown below, to
        /// manually return a new ``GeneratedContent`` with the properties you specify.
        ///
        /// ```swift
        /// struct Person: ConvertibleToGeneratedContent {
        ///    var name: String
        ///    var age: Int
        ///
        ///    var generatedContent: GeneratedContent {
        ///        GeneratedContent(properties: [
        ///            "firstName": name,
        ///            "ageInYears": age
        ///        ])
        ///    }
        /// }
        /// ```
        ///
        /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
        /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
        nonisolated public var generatedContent: GeneratedContent { get }

        /// A representation of partially generated content
        nonisolated public struct PartiallyGenerated : Identifiable, nonisolated ConvertibleFromGeneratedContent {

            /// The stable identity of the entity associated with this instance.
            public var id: GenerationID

            /// Creates an instance from content generated by a model.
            ///
            /// Conformance to this protocol is provided by the `@Generable` macro.
            /// A manual implementation may be used to map values onto properties using
            /// different names. To manually initialize your type from generated content,
            /// decode the values as shown below:
            ///
            /// ```swift
            /// struct Person: ConvertibleFromGeneratedContent {
            ///     var name: String
            ///     var age: Int
            ///
            ///     init(_ content: GeneratedContent) {
            ///         self.name = try content.value(forProperty: "firstName")
            ///         self.age = try content.value(forProperty: "ageInYears")
            ///     }
            /// }
            /// ```
            ///
            /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
            /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
            ///
            /// - SeeAlso: `@Generable` macro ``Generable(description:)``
            nonisolated public init(_ content: GeneratedContent) throws

            /// A type representing the stable identity of the entity associated with

Truncated.

extension BarcodeReaderTool.Arguments : nonisolated Generable {

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    nonisolated public init(_ content: GeneratedContent) throws
}

public enum BarcodeSymbology : CaseIterable, Codable, Equatable, Hashable, Sendable {

    case aztec

    case code39

    case code39Checksum

    case code39FullASCII

    case code39FullASCIIChecksum

    case code93

    case code93i

    case code128

    case dataMatrix

    case ean8

    case ean13

    case i2of5

    case i2of5Checksum

    case itf14

    case pdf417

    case qr

    case upce

    case codabar

    case gs1DataBar

    case gs1DataBarExpanded

    case gs1DataBarLimited

    case microPDF417

    case microQR

    case msiPlessey

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

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

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

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

Truncated.

public protocol BoundingBoxProviding {

    /// The bounding box of the object.
    ///
    /// The coordinate system is normalized to the dimensions of the processed image, with the origin at the lower-left corner of the image.
    var boundingBox: NormalizedRect { get }
}

public protocol BoundingRegionProviding {

    var boundingRegion: NormalizedRegion { get }
}

public struct CalculateImageAestheticsScoresRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = ImageAestheticsScoresObservation

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: CalculateImageAestheticsScoresRequest.Revision, b: CalculateImageAestheticsScoresRequest.Revision) -> 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
    }

Truncated.

extension CGPoint {

    public var formattedDescription: String { get }
}

extension CGRect {

    public var formattedDescription: String { get }
}

extension CGSize {

    public var formattedDescription: String { get }
}

public struct ClassificationObservation : VisionObservation, @unchecked Sendable {

    /// The is the identifier of a classification request. An example classification could be a string like 'cat' or 'hotdog'.
    ///
    /// The string is defined in the model that was used for the classification. Usually these are technical labels that are not localized
    /// and not meant to be used directly to be presented to an end user in the UI.
    public let identifier: String

    /// A Boolean variable indicating whether the observation contains precision and recall curves.
    ///
    /// Precision refers to the percentage of your classification results that are relevant, while recall refers to the percentage of total
    /// relevant results correctly classified. If this property is true, then you can call precision and recall-related methods in this observation.
    /// If this property is false, then the precision and recall-related methods won't return meaningful data.
    public var hasPrecisionRecallCurve: Bool { get }

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

    /// Determines whether the observation has a minimum recall value for a specific precision.
    ///
    /// - Parameters:
    ///  - minimumRecall: The minimum desired percentage of relevant results that the algorithm correctly classified.
    ///  - precision: The percentage of classification results that are relevant.
    ///
    /// - Returns: A Boolean indicating whether or not this classification observation provides a minimum percentage of relevant results that meet the desired precision criterion.
    public func hasMinimumRecall(_ minimumRecall: Float, forPrecision precision: Float) -> Bool

    /// Determines whether the observation has a minimum precision value for a specific recall.
    ///
    /// - Parameters:
    ///   - minimumPrecision: The minimum percentage of classification results that are relevant.
    ///   - recall: The percentage of relevant results that the algorithm correctly classified.
    ///
    /// - Returns: A Boolean indicating whether or not this classification observation provides a minimum percentage of relevant results that meet the desired recall criterion.
    public func hasMinimumPrecision(_ minimumPrecision: Float, forRecall recall: Float) -> Bool

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

Truncated.

extension ClassificationObservation : 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
}

public struct ClassifyImageRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [ClassificationObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision2

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

        /// 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: ClassifyImageRequest.Revision, b: ClassifyImageRequest.Revision) -> 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
    }

Truncated.

public enum ComputeStage : Codable, Equatable, Hashable, Sendable {

    /// A stage that represents where the system performs the main functionality.
    case main

    /// A stage that represents where the system performs additional analysis after the main compute stage.
    case postProcessing

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

public struct ContoursObservation : VisionObservation, @unchecked Sendable {

    /// The total number of detected contours.
    ///
    /// Use this value to determine the number of indices available for calling `contour(at:)`.
    public var contourCount: Int { get }

    /// The detected contours as a path object in normalized coordinates.
    public var normalizedPath: CGPath { get }

    /// An array of contours that don’t have another contour enclosing them.
    ///
    /// This array constitutes the top of the contour hierarchy. You can iterate over each VNContour instance to determine its children.
    public var topLevelContours: [ContoursObservation.Contour] { get }

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

    /// Retrieves the contour object at the specified index, irrespective of hierarchy.
    ///
    /// - Parameters:
    ///   - contourIndex: The index of the contour to retrieve. Valid values are in the range of 0 to contourCount - 1.
    /// - Returns: The contour object at the specified index path, or `nil` if the index path is invalid.
    public func contourAtIndex(_ index: Int) -> ContoursObservation.Contour?

    /// Retrieves the contour object at the specified index path.
    ///
    /// - Parameters:
    ///   - indexPath: The hierarchical index path to the contour.
    /// - Returns: The contour object at the specified index, or `nil` if the index is invalid.
    public func countourAtIndexPath(_ indexPath: IndexPath) -> ContoursObservation.Contour?

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

Truncated.

extension ContoursObservation {

    public struct Contour : @unchecked Sendable, Equatable, Hashable, CustomStringConvertible {

        /// The aspect ratio of the contour.
        ///
        /// The aspect ratio is the original image’s width divided by its height.
        public var aspectRatio: Float { get }

        /// The contour object’s index path.
        public var indexPath: IndexPath { get }

        /// The contour object as a path in normalized coordinates.
        public var normalizedPath: CGPath { get }

        /// The contour’s number of points.
        public var pointCount: Int { get }

        /// The contour’s array of points in normalized coordinates.
        public var normalizedPoints: [simd_float2] { get }

        /// An array of contours that this contour encloses.
        public var childContours: [ContoursObservation.Contour] { get }

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

        /// Calculates the area enclosed by the contour.
        ///
        /// - Parameters:
        ///   - useOrientedArea: Whether to calculate the signed area (positive for counterclockwise-oriented contours and negative for clockwise-oriented contours). If you specify false, the returned area is always positive.
        ///
        /// Attempting to calculate the area for a contour containing random points, or with self-crossing edges, produces undefined results.
        public func calculateArea(useOrientedArea: Bool = false) -> Double

        /// Calculate the perimeter of the contour.
        public func calculatePerimeter() -> Double

        /// Creates a Circle that encloses the contour.
        public func boundingCircle() -> NormalizedCircle

        ///  Simplifies the contour to a polygon using a Ramer-Douglas-Peucker algorithm.
        ///
        ///  - Parameters:
        ///     - epsilon: This parameter defines the distance threshold the algorithm uses. It preserves points whose perpendicular distance to the line segment they are on is greater than epsilon, and removes all others.
        ///  - Returns: A simplified polygon contour from the points of the original contour.
        public func polygonApproximation(epsilon: Float) throws -> ContoursObservation.Contour

        /// 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: ContoursObservation.Contour, b: ContoursObservation.Contour) -> Bool

Truncated.

extension ContoursObservation : 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 ContoursObservation.Contour {

    /// The points of the region as an array of `NormalizedPoint`.
    public var points: [NormalizedPoint] { get }

    /// The bounding quadrilateral of the region.
    public var boundingQuad: RectangleObservation { get }

    /// The bounding box of the region.
    public var boundingBox: NormalizedRect { get }
}

public enum CoordinateOrigin {

    /// The origin is in the upper-left corner of the image
    case upperLeft

    /// The origin is in the lower-left corner of the image
    case lowerLeft

    /// 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: CoordinateOrigin, b: CoordinateOrigin) -> 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 CoordinateOrigin : Equatable {
}

extension CoordinateOrigin : Hashable {
}

public struct CoreMLFeatureValueObservation : VisionObservation {

    /// The name used in the model description of the CoreML model that produced this observation.
    public let featureName: String

    /// The feature result of a ``CoreMLRequest`` that outputs neither a classification nor an image.
    ///
    /// Refer to Core ML documentation and the model itself to learn about proper handling of the content.
    public let featureValue: MLSendableFeatureValue

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

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

public struct CoreMLModelContainer : Equatable, @unchecked Sendable, Hashable {

    /// Creates a model container to use with an image analysis request based on the model you provide.
    ///
    /// - Parameters:
    ///   - model: The Core ML model on which to base the Vision request.
    ///
    /// Initialization can fail if the Core ML model you provide isn’t supported in Vision, such as if the model doesn’t accept an image as input.
    public init(model: MLModel, featureProvider: (any MLFeatureProvider)? = nil) throws

    /// The name of the `MLFeatureValue` that Vision sets from the request handler.
    ///
    /// By default, Vision uses the first input found, but you can manually set that input to another `featureName` instead.
    public var inputImageFeatureName: 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)

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

    /// 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 CoreMLRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [any VisionObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: CoreMLRequest.Revision, b: CoreMLRequest.Revision) -> 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
    }

Truncated.

public struct DetectBarcodesRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [BarcodeObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision4

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

        /// 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: DetectBarcodesRequest.Revision, b: DetectBarcodesRequest.Revision) -> 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
    }

Truncated.

public struct DetectContoursRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = ContoursObservation

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: DetectContoursRequest.Revision, b: DetectContoursRequest.Revision) -> 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
    }

Truncated.

public struct DetectDocumentSegmentationRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = DetectedDocumentObservation?

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: DetectDocumentSegmentationRequest.Revision, b: DetectDocumentSegmentationRequest.Revision) -> 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
    }

Truncated.

public struct DetectedDocumentObservation : VisionObservation, QuadrilateralProviding {

    /// A pixel buffer representing a segmentation mask for the detected document.
    public var globalSegmentationMask: PixelBufferObservation

    /// The coordinates of the upper-left corner of the quadrilateral.
    public var topLeft: NormalizedPoint

    /// The coordinates of the upper-right corner of the quadrilateral.
    public var topRight: NormalizedPoint

    /// The coordinates of the lower-right corner of the quadrilateral.
    public var bottomRight: NormalizedPoint

    /// The coordinates of the lower-left corner of the quadrilateral.
    public var bottomLeft: NormalizedPoint

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

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

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

public struct DetectedObjectObservation : VisionObservation, BoundingBoxProviding {

    public init(boundingBox: NormalizedRect)

    /// The bounding box of the object.
    ///
    /// The coordinate system is normalized to the dimensions of the processed image, with the origin at the lower-left corner of the image.
    public var boundingBox: NormalizedRect

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

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

public struct DetectFaceCaptureQualityRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [FaceObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision3

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

        /// 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: DetectFaceCaptureQualityRequest.Revision, b: DetectFaceCaptureQualityRequest.Revision) -> 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
    }

Truncated.

public struct DetectFaceLandmarksRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [FaceObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision3

        @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
        case revision4

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

        /// 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: DetectFaceLandmarksRequest.Revision, b: DetectFaceLandmarksRequest.Revision) -> 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.

Truncated.

public struct DetectFaceRectanglesRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [FaceObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision3

        @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
        case revision4

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

        /// 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: DetectFaceRectanglesRequest.Revision, b: DetectFaceRectanglesRequest.Revision) -> 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.

Truncated.

public struct DetectHorizonRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = HorizonObservation?

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: DetectHorizonRequest.Revision, b: DetectHorizonRequest.Revision) -> 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
    }

Truncated.

public struct DetectHumanRectanglesRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [HumanObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision2

        @available(macOS 27.0, iOS 27.0, tvOS 27.0, *)
        case revision3

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

        /// 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: DetectHumanRectanglesRequest.Revision, b: DetectHumanRectanglesRequest.Revision) -> 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.

Truncated.

public struct DetectLensSmudgeRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = SmudgeObservation

    /// A type that describes the algorithm or implementation that the request performs.
    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        ///  An algorithm or implementation that represents the first revision.
        case revision1

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

        /// 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: DetectLensSmudgeRequest.Revision, b: DetectLensSmudgeRequest.Revision) -> 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

Truncated.

public struct DetectRectanglesRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [RectangleObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: DetectRectanglesRequest.Revision, b: DetectRectanglesRequest.Revision) -> 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
    }

Truncated.

public struct DownloadableAssetsProgress : AsyncSequence, AsyncIteratorProtocol {

    /// The type of asynchronous iterator that produces elements of this
    /// asynchronous sequence.
    public typealias AsyncIterator = DownloadableAssetsProgress

    /// The type of element produced by this asynchronous sequence.
    public typealias Element = DownloadableAssetsRequestStatus

    /// Asynchronously advances to the next element and returns it, or ends the
    /// sequence if there is no next element.
    ///
    /// - Returns: The next element, if it exists, or `nil` to signal the end of
    ///   the sequence.
    public mutating func next() async -> DownloadableAssetsRequestStatus?

    /// Creates the asynchronous iterator that produces elements of this
    /// asynchronous sequence.
    ///
    /// - Returns: An instance of the `AsyncIterator` type used to produce
    /// elements of the asynchronous sequence.
    public func makeAsyncIterator() -> DownloadableAssetsProgress
}

public protocol DownloadableAssetsRequest {

    func downloadAssets() async throws

    var assetStatus: DownloadableAssetsRequestStatus { get async }

    func downloadAssets(progress: consuming Subprogress) async throws
}

extension DownloadableAssetsRequest {

    public func downloadAssets() async throws

    public func downloadAssets(progress: consuming Subprogress) async throws
}

public enum DownloadableAssetsRequestStatus : Sendable, Equatable {

    case notReady

    case ready

    case error(any Error)

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

public enum ElementType : Codable, Equatable, Hashable, Sendable {

    /// The elements are floating-point numbers.
    case float

    /// The elements are double-precision floating-point numbers.
    case double

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

public struct FaceObservation : VisionObservation, BoundingBoxProviding {

    /// - Parameters:
    ///     - boundingBox: The bounding rectangle of the detected face.
    ///     - revision: The revision of the `DetectFaceRectanglesRequest` that provided the bounding box.
    ///
    ///     If no revision is provided, a default value is assumed. Different revisions can affect how the bounding box is interpreted by Vision.
    public init(boundingBox: NormalizedRect, revision: DetectFaceRectanglesRequest.Revision? = nil)

    /// The facial features of the detected face.
    ///
    /// This value is nil for face observations produced by a `DetectFaceRectanglesRequest` analysis.
    /// Use the `DetectFaceLandmarksRequest` class to find facial features.
    public var landmarks: FaceObservation.Landmarks2D?

    /// The roll angle of a face.
    ///
    /// This value indicates the rotational angle of the face around the z-axis.
    public let roll: Measurement<UnitAngle>

    /// The yaw angle of a face.
    ///
    /// This value indicates the rotational angle of the face around the y-axis.
    public let yaw: Measurement<UnitAngle>

    /// The pitch angle of a face.
    ///
    /// This value indicates the rotational angle of the face around the x-axis.
    public let pitch: Measurement<UnitAngle>

    /// The quality of the face capture.
    ///
    /// This value is nil for face observations produced by a `DetectFaceRectanglesRequest` analysis.
    /// Use ``DetectFaceCaptureQualityRequest`` to detect capture quality.
    public var captureQuality: FaceObservation.CaptureQuality?

    /// The bounding box of the object.
    ///
    /// The coordinate system is normalized to the dimensions of the processed image, with the origin at the lower-left corner of the image.
    public var boundingBox: NormalizedRect

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

Truncated.

extension FaceObservation {

    /// A collection of facial features that a request detects.
    ///
    /// This class represents the set of all detectable 2D face landmarks and regions, exposed as properties. The coordinates of the face landmarks are normalized to the dimensions of the face observation’s `boundingBox`, with the origin at the bounding box’s lower-left corner.
    public struct Landmarks2D : Codable, Equatable, Sendable, CustomStringConvertible, Hashable {

        ///
        public var allPoints: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that trace the face contour from the left cheek, over the chin, to the right cheek.
        public var faceContour: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that outline the left eye.
        public var leftEye: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that outline the right eye.
        public var rightEye: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that trace the left eyebrow.
        public var leftEyebrow: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that trace the right eyebrow.
        public var rightEyebrow: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that outline the nose.
        public var nose: FaceObservation.Landmarks2D.Region { get }

        ///  The region containing points that trace the center crest of the nose.
        public var noseCrest: FaceObservation.Landmarks2D.Region { get }

        ///  The region containing points that trace a vertical line down the center of the face.
        public var medianLine: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that outline the outside of the lips.
        public var outerLips: FaceObservation.Landmarks2D.Region { get }

        /// The region containing points that outline the space between the lips.
        public var innerLips: FaceObservation.Landmarks2D.Region { get }

        ///  The region containing the point where the left pupil is located.
        public var leftPupil: FaceObservation.Landmarks2D.Region { get }

        ///  The region containing the point where the right pupil is located.
        public var rightPupil: FaceObservation.Landmarks2D.Region { get }

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

        public let originatingRequestDescriptor: RequestDescriptor?

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

extension FaceObservation : 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 FaceObservation.Landmarks2D {

    /// 2D geometry information for a specific facial feature.
    public struct Region : Codable, Equatable, Sendable, Hashable, CustomStringConvertible {

        /// The set of classifications that describe how to interpret the points the region provides.
        public enum PointsClassification : Codable, Hashable, Sendable, Equatable {

            case closedPath

            case disconnected

            case openPath

            /// 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: FaceObservation.Landmarks2D.Region.PointsClassification, b: FaceObservation.Landmarks2D.Region.PointsClassification) -> 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
        }

        /// An enumeration that describes how to interpret the points the region provides.
        public let pointsClassification: FaceObservation.Landmarks2D.Region.PointsClassification

        /// The array of landmark points normalized to the bounding box of the `FaceObservation`.
        public let points: [NormalizedPoint]

        /// An array of precision estimates for each landmark point.
        public let precisionEstimatesPerPoint: [Float]?

Truncated.

public struct FeaturePrintObservation : VisionObservation {

    /// The feature print data.
    ///
    /// The data is divided into separate elements. Determine the type of element using ``elementType``, and the number of elements
    /// using ``elementCount``.
    public let data: Data

    /// The total number of elements in the data.
    public let elementCount: Int

    /// The type of each element in the data.
    public let elementType: ElementType

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

    /// Computes the distance between two feature print observations.
    ///
    /// Shorter distances indicate greater similarity between feature prints.
    ///
    /// - Parameters:
    ///   - featurePrint: The feature print object to calculate the distance to.
    public func distance(to featurePrint: FeaturePrintObservation) throws -> Double

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

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

Truncated.

extension FeaturePrintObservation : 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
}

public struct GenerateAttentionBasedSaliencyImageRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = SaliencyImageObservation

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision2

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

        /// 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: GenerateAttentionBasedSaliencyImageRequest.Revision, b: GenerateAttentionBasedSaliencyImageRequest.Revision) -> 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
    }

Truncated.

public struct GenerateForegroundInstanceMaskRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = InstanceMaskObservation?

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: GenerateForegroundInstanceMaskRequest.Revision, b: GenerateForegroundInstanceMaskRequest.Revision) -> 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
    }

Truncated.

public struct GenerateImageFeaturePrintRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = FeaturePrintObservation

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision2

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

        /// 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: GenerateImageFeaturePrintRequest.Revision, b: GenerateImageFeaturePrintRequest.Revision) -> 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
    }

Truncated.

public struct GenerateObjectnessBasedSaliencyImageRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = SaliencyImageObservation

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision2

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

        /// 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: GenerateObjectnessBasedSaliencyImageRequest.Revision, b: GenerateObjectnessBasedSaliencyImageRequest.Revision) -> 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
    }

Truncated.

public struct GeneratePersonInstanceMaskRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = InstanceMaskObservation?

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: GeneratePersonInstanceMaskRequest.Revision, b: GeneratePersonInstanceMaskRequest.Revision) -> 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
    }

Truncated.

public struct GenerateSelectedObjectSegmentationRequest : ImageProcessingRequest, StatefulRequest, DownloadableAssetsRequest {

    public var assetStatus: DownloadableAssetsRequestStatus { get async }

    @available(visionOS, introduced: 27.0, deprecated: 27.0, renamed: "downloadAssetsWithProgress")
    public func downloadWithProgress() throws -> DownloadableAssetsProgress

    public func downloadAssetsWithProgress() throws -> DownloadableAssetsProgress

    /// The reciprocal of maximum rate at which buffers will be processed.
    ///
    /// The request will not process buffers that fall within the `frameAnalysisSpacing` since the previously performed analysis.
    /// The analysis is not done by wall time but by analysis of of the time stamps of the samplebuffers being processed.
    public let frameAnalysisSpacing: CMTime

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = PixelBufferObservation?

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision1

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

        /// 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: GenerateSelectedObjectSegmentationRequest.Revision, b: GenerateSelectedObjectSegmentationRequest.Revision) -> 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

Truncated.

public struct HorizonObservation : VisionObservation {

    /// The transform to apply to the detected horizon.
    ///
    /// Apply the transform's inverse to orient the image in an upright position and make the detected horizon level.
    public let transform: CGAffineTransform

    /// The angle of the observed horizon.
    ///
    /// Use the angle to orient the image in an upright position and make the detected horizon level.
    public let angle: Measurement<UnitAngle>

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

    /// Creates an affine transform for the specified image width and height.
    ///
    /// - Parameters:
    ///    - imageSize: The size of the image.
    /// - Returns: An affine transform. Apply the transform's inverse to orient the image in an upright position and make the detected horizon level.
    public func transform(for imageSize: CGSize) -> CGAffineTransform

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

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

public struct HumanObservation : VisionObservation, BoundingBoxProviding {

    /// A Boolean value that indicates whether the observation represents an upper-body or full-body rectangle.
    public let isUpperBodyOnly: Bool

    /// The bounding box of the object.
    ///
    /// The coordinate system is normalized to the dimensions of the processed image, with the origin at the lower-left corner of the image.
    public let boundingBox: NormalizedRect

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

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

public struct ImageAestheticsScoresObservation : VisionObservation {

    /// A Boolean value that represents images that are not necessarily of poor image quality, but may not have memorable or exciting content.
    public let isUtility: Bool

    /// A score which incorporates aesthetic score, failure score, and utility labels.
    ///
    /// This returns a value within the range of `-1` and `1`, where `-1` is least desirable and `1` is most desirable.
    public let overallScore: Float

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

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

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

public enum ImageCropAndScaleAction : CaseIterable, Codable, Equatable, Hashable, Sendable {

    /// Scale image maintaining aspect ratio to fit on the short side and crop centered on the long side.
    case centerCrop

    /// Scale to size required by algorithm while maintaining the original aspect ratio.
    case scaleToFit

    /// An option that scales the image to fill the input dimensions, resizing it if necessary.
    case scaleToFill

    /// Scale image maintaining aspect ratio to fit on the long side but also rotate by 90 degrees counter clockwise to optimize portrait images to fit into landscape buffers for algorithms that are rotation agnostic.
    case scaleToFitPlus90CCWRotation

    /// Scale image and rotate by 90 degrees counter clockwise to optimize portrait images to fill into landscape buffers for algorithms that are rotation agnostic.
    case scaleToFillPlus90CCWRotation

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

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

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

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

public struct ImageHomographicAlignmentObservation : VisionObservation {

    /// The warp transform matrix to morph the floating image into the reference image.
    public let warpTransform: matrix_float3x3

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

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

public protocol ImageProcessingRequest : VisionRequest {

    /// The region of the image in which Vision will perform the request.
    ///
    /// The rectangle is normalized to the dimensions of the processed image. Its origin is specified relative to the image's lower-left corner.
    /// By default, the region of interest will be the full image.
    var regionOfInterest: NormalizedRect { get set }

    /// Perform the request on a `CVPixelBuffer` and produce observations.
    ///
    /// - Parameters:
    ///   - pixelBuffer: The input `CVPixelBuffer` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    func perform(on pixelBuffer: CVPixelBuffer, orientation: CGImagePropertyOrientation?) async throws -> Self.Result

    /// Perform the request on an image `URL` and produce observations.
    ///
    /// - Parameters:
    ///   - url: The input `URL` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    func perform(on url: URL, orientation: CGImagePropertyOrientation?) async throws -> Self.Result

    /// Perform the request on a `CGImage` and produce observations.
    ///
    /// - Parameters:
    ///   - image: The input `CGImage` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    func perform(on image: CGImage, orientation: CGImagePropertyOrientation?) async throws -> Self.Result

    /// Perform the request on a `CMSampleBuffer` and produce observations.
    ///
    /// - Parameters:
    ///   - sampleBuffer: The input `CMSampleBuffer` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    func perform(on sampleBuffer: CMSampleBuffer, orientation: CGImagePropertyOrientation?) async throws -> Self.Result

    /// Perform the request on image `Data` and produce observations.
    ///
    /// - Parameters:
    ///   - data: The input `Data` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    func perform(on data: Data, orientation: CGImagePropertyOrientation?) async throws -> Self.Result
}

extension ImageProcessingRequest {

    /// Perform the request on a `CVPixelBuffer` and produce observations.
    ///
    /// - Parameters:
    ///   - pixelBuffer: The input `CVPixelBuffer` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    public func perform(on pixelBuffer: CVPixelBuffer, orientation: CGImagePropertyOrientation? = nil) async throws -> Self.Result

    /// Perform the request on an image `URL` and produce observations.
    ///
    /// - Parameters:
    ///   - url: The input `URL` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    public func perform(on url: URL, orientation: CGImagePropertyOrientation? = nil) async throws -> Self.Result

    /// Perform the request on a `CGImage` and produce observations.
    ///
    /// - Parameters:
    ///   - image: The input `CGImage` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    public func perform(on image: CGImage, orientation: CGImagePropertyOrientation? = nil) async throws -> Self.Result

    /// Perform the request on a `CMSampleBuffer` and produce observations.
    ///
    /// - Parameters:
    ///   - sampleBuffer: The input `CMSampleBuffer` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    public func perform(on sampleBuffer: CMSampleBuffer, orientation: CGImagePropertyOrientation? = nil) async throws -> Self.Result

    /// Perform the request on image `Data` and produce observations.
    ///
    /// - Parameters:
    ///   - data: The input `Data` on which to perform the request.
    ///   - orientation: The orientation of the input image. Default is `nil`.
    ///
    /// - Returns: The observation(s) produced by the request.
    public func perform(on data: Data, orientation: CGImagePropertyOrientation? = nil) async throws -> Self.Result
}

public struct ImageTranslationAlignmentObservation : VisionObservation {

    /// The alignment transform to align the floating image with the reference image.
    public let alignmentTransform: CGAffineTransform

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

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

public struct InstanceMaskObservation : VisionObservation, @unchecked Sendable {

    /// The collection that contains all instances, excluding the background.
    public let allInstances: IndexSet

    /// The resulting mask that represents all instances.
    ///
    /// A pixel can only correspond to one instance. A 0 represents the background, and all other values represent the indices of the instances.
    public let allInstancesMask: PixelBufferObservation

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

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

    /// Creates a low-resolution mask from the instances you specify.
    ///
    /// - Parameters:
    ///   - instances: An IndexSet of selected instances, where 0 is the background.
    ///
    /// - Returns: The pixel buffer that contains the mask.
    public func generateMask(for instances: IndexSet) throws -> CVPixelBuffer

    /// Creates a high-resolution image with everything except for the instances you specify masked out.
    ///
    /// The image produced has the same resolution as the image in the `requestHandler`.
    ///
    /// - Parameters:
    ///   - instances: An IndexSet of selected instances, where 0 is the background.
    ///   - requestHandler: A request handler containing an image to be masked.
    ///   - croppedToInstancesExtent: Crops the image to the smallest rectangle contaning all instances
    /// - Returns: The pixel buffer that contains the image.
    public func generateMaskedImage(for instances: IndexSet, imageFrom requestHandler: ImageRequestHandler, croppedToInstancesExtent: Bool = false) throws -> CVPixelBuffer

    /// Creates a high-resolution mask representing a combination of the instances you specify.
    ///
    /// The image produced has the same resolution as the image in the `requestHandler`.
    ///
    /// - Parameters:
    ///   - instances: An IndexSet of selected instances, where 0 is the background.
    ///   - requestHandler: A request handler containing an image.
    ///
    /// - Returns: The pixel buffer that contains the mask.
    public func generateScaledMask(for instances: IndexSet, scaledToImageFrom requestHandler: ImageRequestHandler) throws -> CVPixelBuffer

    /// Creates an index set containing the instance found at the specified point.
    public func instanceAtPoint(_ point: NormalizedPoint) -> IndexSet

Truncated.

extension InstanceMaskObservation : 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
}

public struct Joint : Codable, Equatable, Hashable, Sendable, CustomStringConvertible {

    /// The location of the joint in normalized coordinates.
    public let location: NormalizedPoint

    /// The joint's identifier label.
    public let jointName: String

    /// A confidence score that indicates the detected joint’s accuracy.
    public let confidence: Float

    public func distance(to joint: Joint) -> CGFloat

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

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

Truncated.

public struct NormalizedCircle {

    public init(center: NormalizedPoint, radius: CGFloat)

    public let center: NormalizedPoint

    public let radius: CGFloat

    /// Determines if this circle, including its boundary, contains the specified point.
    public func contains(_ point: NormalizedPoint) -> Bool

    /// Determines if a ring around this circle’s circumference contains the specified point.
    public func contains(_ point: NormalizedPoint, inCircumferentialRingOfWidth ringWidth: CGFloat) -> Bool

    public static var zero: NormalizedCircle { get }

    public static func boundingCircle(for points: [NormalizedPoint]) -> NormalizedCircle
}

public struct NormalizedPoint : Hashable, Equatable, Codable, Sendable, CustomStringConvertible {

    /// Creates a point object with the specified coordinates.
    ///
    /// - Parameters:
    ///   - x: The x-coordinate value.
    ///   - y: The y-coordinate value.
    public init(x: CGFloat, y: CGFloat)

    /// Creates a point object from the specified Core Graphics point.
    public init(normalizedPoint: CGPoint)

    /// Creates a normalized point from a point in an image coordinate space.
    ///
    /// - Parameters:
    ///   - imagePoint: A point in the image coordinate space.
    ///   - imageSize: The size of the image.
    public init(imagePoint: CGPoint, in imageSize: CGSize)

    /// Creates a point normalized to a region of interest within an image.
    ///
    /// - Parameters:
    ///   - imagePoint: A point in the image coordinate space.
    ///   - imageSize: The size of the image.
    ///   - regionOfInterest: The region within the image that the point will be normalized to
    public init(imagePoint: CGPoint, in imageSize: CGSize, normalizedTo regionOfInterest: NormalizedRect)

    /// A point object that represents the origin, [0,0].
    public static var zero: NormalizedPoint { get }

    /// The Core Graphics point for this point.
    public let cgPoint: CGPoint

    /// The x-coordinate.
    public var x: CGFloat { get }

    /// The y-coordinate.
    public var y: CGFloat { get }

    /// Converts a point normalized to a region within an image into full image coordinates.
    ///
    /// - Parameters:
    ///   - imageSize: The size of the image.
    ///   - regionOfInterest: The region within an image the `NormalizedPoint` is normalized to.
    public func toImageCoordinates(from regionOfInterest: NormalizedRect, imageSize: CGSize, origin: CoordinateOrigin = .lowerLeft) -> CGPoint

    /// Converts a point in normalized coordinates into image coordinates.
    ///
    /// - Parameters:
    ///   - imageSize: The size of the image.
    public func toImageCoordinates(_ imageSize: CGSize, origin: CoordinateOrigin = .lowerLeft) -> CGPoint

    /// Returns a `NormalizedPoint` with the origin flipped between the top and bottom of the image.
    public func verticallyFlipped() -> NormalizedPoint

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

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///

Truncated.

public struct NormalizedRect : Equatable, Hashable, Codable, Sendable, CustomStringConvertible {

    /// Creates a rectangle with the specified coordinates.
    ///
    /// - Parameters:
    ///   - x: The x-coordinate of the rectangle's lower-left corner.
    ///   - y: The y-coordinate of the rectangle's lower-left corner..
    ///   - width: The width of the rectangle
    ///   - height: The height of the rectangle
    public init(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat)

    /// Creates a normalized rectangle from a rectangle in an image coordinate space.
    ///
    /// - Parameters:
    ///   - imageRect: A rectangle in the image coordinate space.
    ///   - imageSize: The size of the image.
    public init(imageRect: CGRect, in imageSize: CGSize)

    /// Creates a rectangle normalized to a region of interest in an image from a rectangle in an image coordinate space.
    ///
    /// - Parameters:
    ///   - imageRect: A rectangle in the image coordinate space.
    ///   - imageSize: The size of the image.
    public init(imageRect: CGRect, in imageSize: CGSize, normalizedTo regionOfInterest: NormalizedRect)

    /// Creates a rectangle from the specified Core Graphics rectangle.
    public init(normalizedRect: CGRect)

    /// A normalized rectangle with origin at [0,0] and a width and height of 1.0.
    public static var fullImage: NormalizedRect { get }

    /// The normalized rectangle as a CGRect.
    public let cgRect: CGRect

    /// The lower-left hand corner of the rectangle.
    public var origin: CGPoint { get }

    /// The width of the rectangle
    public var width: CGFloat { get }

    /// The height of the rectangle
    public var height: CGFloat { get }

    /// Converts a rectangle in normalized coordinates into image coordinates.
    ///
    /// - Parameters:
    ///   - imageSize: The size of the image.
    public func toImageCoordinates(_ imageSize: CGSize, origin: CoordinateOrigin = .lowerLeft) -> CGRect

    /// Converts a rectangle normalized to a region within an image into full image coordinates.
    ///
    /// - Parameters:
    ///   - imageSize: The size of the image.
    ///   - regionOfInterest: The region within an image the `NormalizedPoint` is normalized to.
    public func toImageCoordinates(from regionOfInterest: NormalizedRect, imageSize: CGSize, origin: CoordinateOrigin = .lowerLeft) -> CGRect

    /// Returns a `NormalizedRect` with the origin flipped between the top and bottom of the image.
    public func verticallyFlipped() -> NormalizedRect

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

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`

Truncated.

public struct OCRTool : Tool, @unchecked Sendable {

    /// A unique name for the tool, such as "get_weather", "toggleDarkMode", or "search contacts".
    public let name: String

    /// A natural language description of when and how to use the tool.
    public let description: String

    /// Creates a tool for recognizing text in images.
    ///
    /// - Parameters:
    ///   - name: The name of the tool as exposed to the model. If not provided, a default name is used.
    ///   - description: A description of what the tool does, used by the model to determine when to call it. If not provided, a default description is used.
    public init(name: String? = nil, description: String? = nil)

    /// The arguments that this tool should accept.
    ///
    /// Typically arguments are either a ``Generable`` type or ``GeneratedContent``.
    public struct Arguments {

        /// An instance of the generation schema.
        nonisolated public static var generationSchema: GenerationSchema { get }

        /// This instance represented as generated content.
        ///
        /// Conformance to this protocol is provided by the `@Generable` macro.
        /// A manual implementation may be used to map values onto properties using
        /// different names. Use the generated content property as shown below, to
        /// manually return a new ``GeneratedContent`` with the properties you specify.
        ///
        /// ```swift
        /// struct Person: ConvertibleToGeneratedContent {
        ///    var name: String
        ///    var age: Int
        ///
        ///    var generatedContent: GeneratedContent {
        ///        GeneratedContent(properties: [
        ///            "firstName": name,
        ///            "ageInYears": age
        ///        ])
        ///    }
        /// }
        /// ```
        ///
        /// - Important: If your type also conforms to ``ConvertibleFromGeneratedContent``,
        /// it is critical that this implementation be symmetrical with ``ConvertibleFromGeneratedContent/init(_:)``.
        nonisolated public var generatedContent: GeneratedContent { get }

        /// A representation of partially generated content
        nonisolated public struct PartiallyGenerated : Identifiable, nonisolated ConvertibleFromGeneratedContent {

            /// The stable identity of the entity associated with this instance.
            public var id: GenerationID

            /// Creates an instance from content generated by a model.
            ///
            /// Conformance to this protocol is provided by the `@Generable` macro.
            /// A manual implementation may be used to map values onto properties using
            /// different names. To manually initialize your type from generated content,
            /// decode the values as shown below:
            ///
            /// ```swift
            /// struct Person: ConvertibleFromGeneratedContent {
            ///     var name: String
            ///     var age: Int
            ///
            ///     init(_ content: GeneratedContent) {
            ///         self.name = try content.value(forProperty: "firstName")
            ///         self.age = try content.value(forProperty: "ageInYears")
            ///     }
            /// }
            /// ```
            ///
            /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
            /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
            ///
            /// - SeeAlso: `@Generable` macro ``Generable(description:)``
            nonisolated public init(_ content: GeneratedContent) throws

            /// A type representing the stable identity of the entity associated with

Truncated.

extension OCRTool.Arguments : nonisolated Generable {

    /// Creates an instance from content generated by a model.
    ///
    /// Conformance to this protocol is provided by the `@Generable` macro.
    /// A manual implementation may be used to map values onto properties using
    /// different names. To manually initialize your type from generated content,
    /// decode the values as shown below:
    ///
    /// ```swift
    /// struct Person: ConvertibleFromGeneratedContent {
    ///     var name: String
    ///     var age: Int
    ///
    ///     init(_ content: GeneratedContent) {
    ///         self.name = try content.value(forProperty: "firstName")
    ///         self.age = try content.value(forProperty: "ageInYears")
    ///     }
    /// }
    /// ```
    ///
    /// - Important: If your type also conforms to ``ConvertibleToGeneratedContent``,
    /// it is critical that this implementation be symmetrical with ``ConvertibleToGeneratedContent/generatedContent``.
    ///
    /// - SeeAlso: `@Generable` macro ``Generable(description:)``
    nonisolated public init(_ content: GeneratedContent) throws
}

public struct OpticalFlowObservation : VisionObservation, @unchecked Sendable {

    /// The size of the observation image.
    public var size: CGSize { get }

    /// The four-character code OSType identifier for the pixel format.
    public var pixelFormat: OSType { get }

    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public var pixelBuffer: CVReadOnlyPixelBuffer { get }

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

    @available(*, deprecated, renamed: "pixelBuffer.withUnsafeBuffer")
    public func withUnsafePointer<R>(_ body: (UnsafeRawPointer) -> R) -> R

    /// Returns the optical flow for the specified location in the observation image
    public func flow(at point: NormalizedPoint) -> (Float, Float)

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

    /// 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 PixelBufferObservation : VisionObservation, @unchecked Sendable {

    /// The size of the observation image.
    public var size: CGSize { get }

    /// The four-character code OSType identifier for the pixel format.
    public var pixelFormat: OSType { get }

    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public var pixelBuffer: CVReadOnlyPixelBuffer { get }

    /// A Core Graphics image created from the pixel buffer observation.
    public var cgImage: CGImage { get throws }

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

    @available(*, deprecated, renamed: "pixelBuffer.withUnsafeBuffer")
    public func withUnsafePointer<R>(_ body: (UnsafeRawPointer) -> R) -> R

    /// Returns the pixel data for the specified location in the image
    public func pixel(at point: NormalizedPoint) -> Float

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

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

Truncated.

public protocol PoseProviding {

    associatedtype PoseJointName : Decodable, Encodable, Hashable, RawRepresentable where Self.PoseJointName.RawValue == String

    associatedtype PoseJointsGroupName : CaseIterable, RawRepresentable where Self.PoseJointsGroupName.RawValue == String

    /// The names of the available joints in the observation.
    var availableJointNames: [Self.PoseJointName] { get }

    /// The names of the available joint groupings in the observation.
    var availableJointsGroupNames: [Self.PoseJointsGroupName] { get }

    /// Retrieves a  joint for a given joint name.
    func joint(for jointName: Self.PoseJointName) -> Joint?

    /// Retrieves a dictionary of joints for a joint group.
    func allJoints(in groupName: Self.PoseJointsGroupName?) -> [Self.PoseJointName : Joint]
}

public protocol QuadrilateralProviding : BoundingBoxProviding {

    /// The coordinates of the upper-left corner of the quadrilateral.
    var topLeft: NormalizedPoint { get }

    /// The coordinates of the upper-right corner of the quadrilateral.
    var topRight: NormalizedPoint { get }

    /// The coordinates of the lower-right corner of the quadrilateral.
    var bottomRight: NormalizedPoint { get }

    /// The coordinates of the lower-left corner of the quadrilateral.
    var bottomLeft: NormalizedPoint { get }
}

extension QuadrilateralProviding {

    /// The bounding box of the object.
    ///
    /// The coordinate system is normalized to the dimensions of the processed image, with the origin at the lower-left corner of the image.
    public var boundingBox: NormalizedRect { get }
}

public struct RecognizeAnimalsRequest : ImageProcessingRequest {

    /// The type produced by performing a Request.
    ///
    /// This type will either be a single VisionObservation or array of VisionObservations.
    public typealias Result = [RecognizedObjectObservation]

    public enum Revision : Comparable, Sendable, Equatable, Codable, Hashable {

        case revision2

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

        /// 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: RecognizeAnimalsRequest.Revision, b: RecognizeAnimalsRequest.Revision) -> 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
    }

Truncated.

extension RecognizeAnimalsRequest.Animal : RawRepresentable {
}

public struct RecognizedObjectObservation : VisionObservation, BoundingBoxProviding {

    /// The classification(s) of the recognized object.
    public let labels: [ClassificationObservation]

    /// The bounding box of the object.
    ///
    /// The coordinate system is normalized to the dimensions of the processed image, with the origin at the lower-left corner of the image.
    public let boundingBox: NormalizedRect

    /// The unique identifier for the observation.
    public let uuid: UUID

    /// The level of confidence normalized to `[0, 1]` where `1` is most confident.
    ///
    /// The only exception is results coming from `CoreMLRequest`, where confidence values are forwarded as is from relevant CoreML models
    public let confidence: Float

    /// The time range of the reported observation.
    ///
    /// When evaluating a sequence of image buffers, use this property to determine each observation’s start time and duration.
    public let timeRange: CMTimeRange?

    /// The descriptor of the request that produced the observation.
    public let originatingRequestDescriptor: RequestDescriptor?

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

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

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