What's new in ARKit

extension AccessoryAnchor : ARKitCoordinateSpaceProviding {
}

public struct ARKitCoordinateSpace : CoordinateSpace3DFloat {

    /// The parent space of this ARKit coordinate space.
    public var ancestorSpace: WorldReferenceCoordinateSpace? { get }

    /// Get the transformation to ancestor space from this ARKit coordinate space.
    ///
    /// - Returns: The transformation to ancestor space from this ARKit coordinate space.
    public func ancestorFromSpaceTransformFloat() -> ProjectiveTransform3DFloat

    /// A correction type to apply on coordinate spaces returned from ARKit APIs.
    @frozen public enum Correction : CustomStringConvertible {

        /// Coordinate spaces are unaltered and represent actual locations.
        case none

        /// Coordinate spaces are corrected to render over physical objects in passthrough displays.
        case rendered

        /// Textual description of this correction type.
        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: ARKitCoordinateSpace.Correction, b: ARKitCoordinateSpace.Correction) -> 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 }
    }

    @available(macOS 27.0, visionOS 26.0, *)
    public typealias AncestorCoordinateSpace = WorldReferenceCoordinateSpace
}

extension ARKitCoordinateSpace.Correction : Equatable {
}

extension ARKitCoordinateSpace.Correction : Hashable {
}

extension ARKitCoordinateSpace.Correction : Sendable {
}

extension ARKitCoordinateSpace.Correction : BitwiseCopyable {
}

public protocol ARKitCoordinateSpaceProviding {

    /// The coordinate space of this object.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The coordinate space.
    func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension ARKitSession.Events.Iterator : @unchecked Sendable {
}

extension BarcodeAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension CameraRegionAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension DeviceAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

public enum DeviceFitStatus : CustomStringConvertible, Sendable {

    /// User's eyes are properly positioned within the optimal device fit range.
    case valid

    /// User's eyes are positioned above the optimal device fit range.
    case eyesAbove

    /// User's eyes are positioned below the optimal device fit range.
    case eyesBelow

    /// User's eyes are positioned to the left of the optimal device fit range.
    case eyesLeft

    /// User's eyes are positioned to the right of the optimal device fit range.
    case eyesRight

    /// A textual representation of the device fit status.
    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: DeviceFitStatus, b: DeviceFitStatus) -> 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 DeviceFitStatus : Equatable {
}

extension DeviceFitStatus : Hashable {
}

extension EnvironmentProbeAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

public struct FieldOfViewAnchor : Anchor, ARKitCoordinateSpaceProviding, @unchecked Sendable, Equatable {

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

    /// A textual representation of this anchor.
    public var description: String { get }

    /// Left eye polygon boundary points defining the preset field of view.
    ///
    /// Each point represents a vertex of the polygon boundary, ordered to form a continuous
    /// polygon. Points are expressed in the anchor's coordinate frame.
    public var leftPolygonPoints: [simd_float4] { get }

    /// Right eye polygon boundary points defining the preset field of view.
    ///
    /// Each point represents a vertex of the polygon boundary, ordered to form a continuous
    /// polygon. Points are expressed in the anchor's coordinate frame.
    public var rightPolygonPoints: [simd_float4] { get }

    /// The unique identifier of this anchor.
    public var id: UUID { get }

    /// The timestamp of this anchor.
    public var timestamp: TimeInterval { get }

    /// The transform from the anchor to the origin coordinate system.
    public var originFromAnchorTransform: simd_float4x4 { get }

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace

    /// A type representing the stable identity of the entity associated with
    /// an instance.
    @available(visionOS 27.0, *)
    @available(macOS, unavailable)
    public typealias ID = UUID
}

extension HandAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension HandSkeleton.Joint : ARKitCoordinateSpaceProviding {

    /// The joint's coordinate space.
    ///
    /// - Parameters:
    ///   - correction: Correction type to apply.
    ///
    /// - Returns: The joint's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension ImageAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension MeshAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension ObjectAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    @available(visionOS 27.0, *)
    @available(macOS, unavailable)
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension PlaneAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

extension RoomAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

public struct VisualFidelityData : @unchecked Sendable, CustomStringConvertible, Equatable {

    /// The timestamp when this validation data was captured.
    public var timestamp: TimeInterval { get }

    /// The device fit validation status.
    ///
    /// Indicates whether the user's eyes are properly positioned within the optimal device fit range,
    /// or provides directional feedback if positioned outside.
    ///
    /// Note: Returns `.valid`  if the provider was created without requesting device fit updates.
    public var deviceFitStatus: DeviceFitStatus { get }

    /// Indicates whether the field of view (FoV) is valid.
    ///
    /// Returns `true` if the expected FoV meets requirements.
    /// Returns `false` if any portion of the FoV is invalid.
    ///
    /// Note: Returns `true` if the provider was created without a field of view.
    public var isFieldOfViewValid: Bool { get }

    /// A textual representation of this visual fidelity data.
    public var description: String { get }

    /// Compares two visual fidelity data instances for equality.
    public static func == (lhs: VisualFidelityData, rhs: VisualFidelityData) -> Bool
}

extension VisualFidelityProvider {

    /// A field of view (FoV) specification.
    ///
    /// The preset FoVs are the recommended specification method for most applications.
    /// They provide standardized FoV requirements.
    @available(visionOS 27.0, *)
    @available(macOS, unavailable)
    public struct FieldOfView : Sendable, Hashable, CustomStringConvertible {

        /// Preset field of view A.
        ///
        /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
        public static let presetA: VisualFidelityProvider.FieldOfView

        /// Preset field of view B.
        ///
        /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
        public static let presetB: VisualFidelityProvider.FieldOfView

        /// Preset field of view C.
        ///
        /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
        public static let presetC: VisualFidelityProvider.FieldOfView

        /// Preset field of view D.
        ///
        /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
        public static let presetD: VisualFidelityProvider.FieldOfView

        /// Creates a polygon-based field of view.
        public static func polygon(points: [simd_float2]) -> VisualFidelityProvider.FieldOfView

        /// Validates whether this field of view specification is valid.
        public var isValid: Bool { get }

        /// A textual representation of the field of view.
        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: VisualFidelityProvider.FieldOfView, b: VisualFidelityProvider.FieldOfView) -> 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 WorldAnchor : ARKitCoordinateSpaceProviding {

    /// The anchor's coordinate space.
    /// - Parameters:
    ///   - correction: Correction type to apply.
    /// - Returns: The anchor's coordinate space.
    public func coordinateSpace(correction: ARKitCoordinateSpace.Correction) -> ARKitCoordinateSpace
}

public struct Configuration : CustomStringConvertible, Sendable, Equatable {

    /// Returns a Boolean value indicating whether two configurations are equal.
    ///
    /// - Parameters:
    ///   - lhs: The left-hand side configuration to compare.
    ///   - rhs: The right-hand side configuration to compare.
    ///
    /// - Returns: `true` if the two configurations are equal; otherwise, `false`.
    public static func == (lhs: ReferenceObject.Configuration, rhs: ReferenceObject.Configuration) -> Bool

    /// Whether to enable high frame-rate tracking for this object.
    public var highFrameRateTrackingEnabled: Bool

    /// A textual representation of this reference object configuration.
    public var description: String { get }

    /// Create a reference object configuration.
    public init()
}

public struct FieldOfView : Sendable, Hashable, CustomStringConvertible {

    /// Preset field of view A.
    ///
    /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
    public static let presetA: VisualFidelityProvider.FieldOfView

    /// Preset field of view B.
    ///
    /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
    public static let presetB: VisualFidelityProvider.FieldOfView

    /// Preset field of view C.
    ///
    /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
    public static let presetC: VisualFidelityProvider.FieldOfView

    /// Preset field of view D.
    ///
    /// To learn more about this preset you can visualize the `FieldOfViewAnchor`.
    public static let presetD: VisualFidelityProvider.FieldOfView

    /// Creates a polygon-based field of view.
    public static func polygon(points: [simd_float2]) -> VisualFidelityProvider.FieldOfView

    /// Validates whether this field of view specification is valid.
    public var isValid: Bool { get }

    /// A textual representation of the field of view.
    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: VisualFidelityProvider.FieldOfView, b: VisualFidelityProvider.FieldOfView) -> 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 }
}