What's new in AVSystemRouting

extension __AVSystemRoute {

    /// A data channel for communicating with the extension outside of any media session.
    ///
    /// Use this channel for control messages, state synchronization, and other bidirectional
    /// communication needs that are not tied to a specific ``AVSystemRouteSession-5i6j6``.
    open var routeDataChannel: __AVSystemRouteDataChannel { get }
}

extension AVSystemRoute.LaunchMode : Equatable {
}

extension AVSystemRoute.LaunchMode : Hashable {
}

public protocol AVSystemRouteControllerObserver : AnyObject {

    /// Connects to, or disconnects from, a device when a user requests it in the
    /// picker.
    ///
    /// - Parameters:
    ///   - controller: The system routing controller.
    ///   - event: The routing event to handle.
    func systemRouteController(_ controller: AVSystemRouteController, handle event: AVSystemRouteEvent) async -> Bool
}

extension AVSystemRouteControllerObserver {

    /// Connects to, or disconnects from, a device when a user requests it in the
    /// picker.
    ///
    /// - Parameters:
    ///   - controller: The system routing controller.
    ///   - event: The routing event to handle.
    /// - Returns: `true` if the event was handled successfully, `false` otherwise.
    public func systemRouteController(_ controller: AVSystemRouteController, handle event: AVSystemRouteEvent) async -> Bool
}

public protocol AVSystemRouteDataDelegate : AnyObject {

    /// Receives data sent from a connected remote applicaiton.
    ///
    /// - Parameter data: The data received from the remote app.
    ///
    /// - Throws: An error if processing the received data fails.
    func receive(_ data: Data) async throws
}

extension AVSystemRouteEvent.Reason : Equatable {
}

extension AVSystemRouteEvent.Reason : Hashable {
}

public enum AVSystemRouteEventReason : Int, @unchecked Sendable {

    /// A value that indicates a user selected a route in the picker.
    case activate = 0

    /// A value that indicates a user deselected a route in the picker.
    case deactivate = 1
}

public enum AVSystemRouteLaunchMode : Int, @unchecked Sendable {

    /// Launches the corresponding application on the remote device.
    	///
    	/// Use this mode when you want to start your app's counterpart on the remote device,
    	/// enabling app-to-application communication and custom playback experiences. The remote application
    	/// can handle the provided URL and maintain bidirectional communication through the
    	/// `AVSystemRouteDataChannel` returned in the completion handler.
    	///
    	/// Application identifiers must be configured in the `MDESupportedProtocols`
    	/// key in your app's `Info.plist` file. For example:
    	/// ```xml
    	/// <key>MDESupportedProtocols</key>
    	///	<dict>
    	///		<key>com.example.sharingprotocol</key>
    	///		<string>com.example.myapplicationidentifier</string>
    	/// </dict>
    	/// ```
    	///
    	/// - Important: If `MDESupportedProtocols` is not set, calls to
    	///              ``AVSystemRouteSession/startWithCompletionHandler:`` fail.
    case application = 0

    /// Launches the system's built-in media player on the remote device.
    	///
    	/// Use this mode when you want to use the remote device's built-in media player
    	/// instead of launching a custom application. This provides a standardized playback
    	/// experience without requiring a corresponding application to be installed on the remote device.
    	///
    	/// To support the `AVSystemRouteLaunchModePlayer` launch mode,
    	/// the `MDESupportsUniversalURLPlayback` key must be set in the app's `Info.plist` file. For example:
    	/// ```xml
    	/// <key>MDESupportsUniversalURLPlayback</key>
    	/// <true/>
    	/// ```
    	///
    	/// - Important: If `MDESupportsUniversalURLPlayback` is not set to `true`, calls to
    	///              ``AVSystemRouteSession/startWithCompletionHandler:`` fail.
    case player = 1
}

public struct AVSystemRoutingError : CustomNSError, Hashable, Error {

    public init(_nsError: NSError)

    public static var errorDomain: String { get }

    /// An error that an AVSystemRouting operation throws when it fails.
    @available(iOS 27.0, *)
    public enum Code : Int, @unchecked Sendable, Equatable {

        /// An error that an AVSystemRouting operation throws when it fails.
        public typealias _ErrorType = AVSystemRoutingError

        /// A connection failure with the remote application.
        case connectionFailed = -73985
    }

    /// A connection failure with the remote application.
    public static var connectionFailed: AVSystemRoutingError.Code { get }
}

public struct AVSystemRoutingError : LocalizedError, Sendable {

    /// The codes that identify the type of a routing error.
    public enum Code : Sendable {

        /// A connection failure with the remote application.
        case connectionFailed

        /// 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: AVSystemRoutingError.Code, b: AVSystemRoutingError.Code) -> Bool

        /// Hashes the essential components of this value by feeding them into the
        /// given hasher.
        ///
        /// Implement this method to conform to the `Hashable` protocol. The
        /// components used for hashing must be the same as the components compared
        /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
        /// with each of these components.
        ///
        /// - Important: In your implementation of `hash(into:)`,
        ///   don't call `finalize()` on the `hasher` instance provided,
        ///   or replace it with a different instance.
        ///   Doing so may become a compile-time error in the future.
        ///
        /// - Parameter hasher: The hasher to use when combining the components
        ///   of this instance.
        public func hash(into hasher: inout Hasher)

        /// The hash value.
        ///
        /// Hash values are not guaranteed to be equal across different executions of
        /// your program. Do not save hash values to use during a future execution.
        ///
        /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
        ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
        ///   The compiler provides an implementation for `hashValue` for you.
        public var hashValue: Int { get }
    }

    /// The code that identifies the type of routing error.
    public let code: AVSystemRoutingError.Code

    /// Creates an error with the specified error code.
    ///
    /// - Parameter code: The error code for this error.
    public init(_ code: AVSystemRoutingError.Code)

    /// A localized description of the error.
    public var errorDescription: String? { get }

    /// A localized explanation of the reason for the error.
    public var failureReason: String? { get }

    /// A localized suggestion for how to recover from the error.
    public var recoverySuggestion: String? { get }

    /// A localized help anchor for the error.
    public var helpAnchor: String? { get }
}

extension AVSystemRoutingError.Code : Equatable {
}

extension AVSystemRoutingError.Code : Hashable {
}

public enum LaunchMode : Sendable {

    /// Launches the corresponding application on the remote device.
    ///
    /// Use this mode when you want to start your app's counterpart on the remote device,
    /// enabling app-to-application communication and custom playback experiences. The remote application
    /// can handle the provided URL and maintain bidirectional communication through the
    /// ``AVSystemRoute/DataChannel`` returned by ``AVSystemRouteSession/start()``.
    ///
    /// Application identifiers must be configured in the `MDESupportedProtocols`
    /// key in your app's `Info.plist` file. For example:
    /// ```xml
    /// <key>MDESupportedProtocols</key>
    ///	<dict>
    ///		<key>com.example.sharingprotocol</key>
    ///		<string>com.example.myapplicationidentifier</string>
    /// </dict>
    /// ```
    ///
    /// - Important: If `MDESupportedProtocols` is not set, calls to
    ///              ``AVSystemRouteSession/start()`` fail.
    case application

    /// Launches the system's built-in media player on the remote device.
    ///
    /// Use this mode when you want to use the remote device's built-in media player
    /// instead of launching a custom application. This provides a standardized playback
    /// experience without requiring a corresponding application to be installed on the remote device.
    ///
    /// To support the ``AVSystemRoute/LaunchMode/player`` launch mode, the `MDESupportsUniversalURLPlayback`
    /// key must be set in the app's `Info.plist` file. For example:
    /// ```xml
    /// <key>MDESupportsUniversalURLPlayback</key>
    /// <true/>
    /// ```
    ///
    /// - Important: If `MDESupportsUniversalURLPlayback` is not set to `true`, calls to
    ///              ``AVSystemRouteSession/start()`` fail.
    case player

    /// 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: AVSystemRoute.LaunchMode, b: AVSystemRoute.LaunchMode) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

public enum Reason : Sendable {

    /// A value that indicates a user selected a route in the picker.
    case activate

    /// A value that indicates a user deselected a route in the picker.
    case deactivate

    /// 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: AVSystemRouteEvent.Reason, b: AVSystemRouteEvent.Reason) -> Bool

    /// Hashes the essential components of this value by feeding them into the
    /// given hasher.
    ///
    /// Implement this method to conform to the `Hashable` protocol. The
    /// components used for hashing must be the same as the components compared
    /// in your type's `==` operator implementation. Call `hasher.combine(_:)`
    /// with each of these components.
    ///
    /// - Important: In your implementation of `hash(into:)`,
    ///   don't call `finalize()` on the `hasher` instance provided,
    ///   or replace it with a different instance.
    ///   Doing so may become a compile-time error in the future.
    ///
    /// - Parameter hasher: The hasher to use when combining the components
    ///   of this instance.
    public func hash(into hasher: inout Hasher)

    /// The hash value.
    ///
    /// Hash values are not guaranteed to be equal across different executions of
    /// your program. Do not save hash values to use during a future execution.
    ///
    /// - Important: `hashValue` is deprecated as a `Hashable` requirement. To
    ///   conform to `Hashable`, implement the `hash(into:)` requirement instead.
    ///   The compiler provides an implementation for `hashValue` for you.
    public var hashValue: Int { get }
}

public enum Code : Int, @unchecked Sendable, Equatable {

    /// An error that an AVSystemRouting operation throws when it fails.
    public typealias _ErrorType = AVSystemRoutingError

    /// A connection failure with the remote application.
    case connectionFailed = -73985
}