What's new in ProximityReader

public enum CustomerEngagement {

    /// A token that authenticates access to a customer engagement session.
    public struct Token : Sendable {

        /// Creates a customer engagement token.
        ///
        /// This creates a token using the ``PaymentCardReader/Token`` from your payment service provider.
        ///
        /// - Parameters:
        ///   - token: The token from your payment service provider.
        public init(using token: PaymentCardReader.Token)
    }

    /// A predefined set of customer engagement screen states.
    public enum Status : Sendable {

        /// A screen indicating the session is ready for customer interaction.
        case ready

        /// A screen indicating a payment is complete.
        case paymentCompleted

        /// A screen indicating a payment failure.
        case paymentFailed

        /// A screen indicating the checkout is complete.
        case checkoutCompleted

        /// 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: CustomerEngagement.Status, b: CustomerEngagement.Status) -> 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 }
    }

    /// A token referencing the shopping cart.
    ///
    /// Use this token to make a payment request.
    ///
    public struct ShoppingCartToken : Sendable {
    }

    /// A structure that describes the shopping cart content.
    public struct ShoppingCart : Sendable {

        /// The items in the shopping cart.
        public let items: [CustomerEngagement.ShoppingCart.Item]

Truncated.

extension CustomerEngagement.Status : Equatable {
}

extension CustomerEngagement.Status : Hashable {
}

extension CustomerEngagementSession.ConsentOption : Equatable {
}

extension CustomerEngagementSession.ConsentOption : Hashable {
}

extension CustomerEngagementSession.Error : Equatable {
}

extension CustomerEngagementSession.Error : Hashable {
}

extension CustomerEngagementSession.Event : Equatable {
}

extension CustomerEngagementSession.Event : Hashable {
}

extension CustomerEngagementSession.PeerClientType : Equatable {
}

extension CustomerEngagementSession.PeerClientType : Hashable {
}

extension CustomerEngagementSession.Purpose : Equatable {
}

extension CustomerEngagementSession.Purpose : Hashable {
}

public struct MobileDocumentHolderName : Hashable, Sendable {

    /// A string representation of the name.
    ///
    /// If available, this string will be taken directly from the underlying document.
    /// If not, then it will be synthesized by formatting the available name components
    /// from the underlying document.
    public let name: String

    /// A component representation of the name.
    ///
    /// If available, these components will be taken directly from the underlying document.
    /// If not, the components will be derived from the full name String on the underlying document.
    public let components: PersonNameComponents

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