What's new in AppIntentsTypeSupport

public struct AppEntityIdentifier : Equatable, Sendable {

    /// The type identifier that defines what kind of entity this is.
    ///
    /// This identifier includes information about the entity's type and any
    /// relevant attributes associated with it, uniquely identifying the
    /// entity type within the application's bundle.
    public let entityType: AttributedTypeIdentifier

    /// The string that uniquely identifies this specific entity instance.
    ///
    /// This identifier distinguishes between different instances of the same
    /// entity type. It must be unique within the scope of its entity type.
    public let instanceIdentifier: String

    /// Creates an attributed entity identifier with the specified type and instance identifiers.
    ///
    /// - Parameters:
    ///   - entityType: The type identifier for this entity.
    ///   - instanceIdentifier: The string that uniquely identifies this specific instance.
    public init(entityType: AttributedTypeIdentifier, instanceIdentifier: String)

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

extension Array : IntentValueConvertible where Element : IntentValueConvertible {

    /// Creates a container that represents this array of intent values.
    ///
    /// This method converts each element in the array to its container representation
    /// and wraps them in an `ArrayContainerElement`.
    ///
    /// - Parameter context: The context to use for the conversion.
    /// - Returns: An intent value container representing this array.
    public func makeContainer(context: IntentValueContainer.ConversionContext) -> IntentValueContainer
}

extension Array : IntentValueExpressing where Element : IntentValueConvertible {

    /// Creates a pending expression of an array of intent values.
    ///
    /// The system evaluates the expression when needed,
    /// allowing for lazy conversion of the array's elements.
    ///
    /// - Returns: An intent value expression representing this array.
    public func makeExpression() -> IntentValueExpression
}

public struct AttributedEntityIdentifier : Equatable, Sendable {

    /// The type identifier that defines what kind of entity this is.
    ///
    /// This identifier includes information about the entity's type and any
    /// relevant attributes associated with it, uniquely identifying the
    /// entity type within the application's bundle.
    public let entityType: AttributedTypeIdentifier

    /// The string that uniquely identifies this specific entity instance.
    ///
    /// This identifier distinguishes between different instances of the same
    /// entity type. It must be unique within the scope of its entity type.
    public let instanceIdentifier: String

    /// Creates an attributed entity identifier with the specified type and instance identifiers.
    ///
    /// - Parameters:
    ///   - entityType: The type identifier for this entity.
    ///   - instanceIdentifier: The string that uniquely identifies this specific instance.
    public init(entityType: AttributedTypeIdentifier, instanceIdentifier: String)

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

extension AttributedString : IntentValueConvertible {

    /// Creates a container that represents the attributed string.
    ///
    /// This method converts the `AttributedString` to an `NSAttributedString` and wraps it
    /// in an intent value container.
    ///
    /// - Parameter context: The context to use for the conversion.
    /// - Returns: An intent value container representing this attributed string.
    public func makeContainer(context: IntentValueContainer.ConversionContext) -> IntentValueContainer
}

public struct AttributedTypeIdentifier : Equatable, Sendable {

    /// The bundle identifier that contains this entity type.
    ///
    /// When non-nil, this value identifies the application bundle that defines the entity type.
    /// This helps distinguish between entity types with the same name across different applications.
    public let bundleIdentifier: String?

    /// The persistent identifier for this entity type.
    ///
    /// This identifier typically corresponds to the struct name of the original entity declaration
    /// (for example, `LandmarkEntity`). The system uses this value to uniquely identify the entity
    /// type within its bundle.
    public let persistentIdentifier: String

    /// Creates a new attributed type identifier.
    ///
    /// - Parameters:
    ///   - persistentIdentifier: The persistent identifier for the entity type, typically the struct name.
    ///   - bundleIdentifier: The optional bundle identifier that contains this entity type.
    public init(persistentIdentifier: String, bundleIdentifier: String? = nil)

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

extension Bool : IntentValueConvertible {
}

extension CLPlacemark : IntentValueConvertible {
}

extension Date : IntentValueConvertible {
}

extension DateComponents : IntentValueConvertible {
}

extension DateInterval : IntentValueConvertible {
}

extension Double : IntentValueConvertible {
}

extension Duration : IntentValueConvertible {
}

extension Int : IntentValueConvertible {
}

extension Int16 : IntentValueConvertible {
}

extension Int32 : IntentValueConvertible {
}

extension Int64 : IntentValueConvertible {
}

extension Int8 : IntentValueConvertible {
}

public struct IntentValueContainer : Sendable, Equatable {

    /// A context that provides additional information for value conversion.
    ///
    /// The `ConversionContext` encapsulates contextual information that might be needed
    /// during the conversion process. Use it to customize how the system converts values to and from containers.
    public struct ConversionContext : Sendable, Hashable {

        /// 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: IntentValueContainer.ConversionContext, b: IntentValueContainer.ConversionContext) -> 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 }
    }

    /// Returns a Boolean value indicating whether two containers are equal.
    ///
    /// Two containers are considered equal if their elements are equal,
    /// as determined by the `equals(other:)` method of the container elements.
    ///
    /// - Parameters:
    ///   - lhs: A container to compare.
    ///   - rhs: Another container to compare.
    /// - Returns: `true` if the containers are equal; otherwise, `false`.
    public static func == (lhs: IntentValueContainer, rhs: IntentValueContainer) -> Bool
}

extension IntentValueContainer : IntentValueExpressing {

    /// Creates an intent value expression that represents this container.
    ///
    /// This method creates an expression that wraps this container directly,
    /// allowing for lazy evaluation during the conversion process.
    ///
    /// - Returns: An intent value expression representing this container.
    public func makeExpression() -> IntentValueExpression
}

public protocol IntentValueConvertible : IntentValueExpressing {

    /// Creates an intent value container that represents this value.
    ///
    /// This method converts the value to a type-erased container that App Intents can use.
    /// The container encapsulates the value and provides
    /// mechanisms for type-safe access and conversion.
    ///
    /// - Parameter context: The context to use for the conversion.
    /// - Returns: An intent value container representing this value.
    func makeContainer(context: IntentValueContainer.ConversionContext) -> IntentValueContainer
}

extension IntentValueConvertible {

    /// Creates an intent value expression that represents this value.
    ///
    /// This implementation creates an expression that wraps this value directly,
    /// allowing for lazy evaluation during the conversion process.
    ///
    /// - Returns: An intent value expression representing this value.
    public func makeExpression() -> IntentValueExpression
}

public protocol IntentValueConvertibleWrapper : IntentValueConvertible {

    /// The underlying type that provides protocol conformance.
    associatedtype BaseValue : IntentValueConvertible

    /// Creates a new instance that wraps the specified base value.
    ///
    /// - Parameter baseValue: The underlying value to wrap.
    /// - Throws: An error if the wrapper cannot be initialized with the given base value.
    init(baseValue: Self.BaseValue) throws

    /// The underlying value that this type wraps.
    var baseValue: Self.BaseValue { get }
}

extension IntentValueConvertibleWrapper {

    /// Creates an intent value container that represents this wrapper.
    ///
    /// This implementation delegates to the base value's container creation method,
    /// ensuring that the wrapper behaves consistently with its underlying type.
    ///
    /// - Parameter context: The context to use for the conversion.
    /// - Returns: An intent value container representing this wrapper.
    public func makeContainer(context: IntentValueContainer.ConversionContext) -> IntentValueContainer
}

public protocol IntentValueExpressing : Sendable {

    /// Creates an intent value expression that represents this value.
    ///
    /// This method creates an expression that the system can evaluate later to produce
    /// an intent value container.
    ///
    /// - Returns: An intent value expression representing this value.
    func makeExpression() -> IntentValueExpression
}

public struct IntentValueExpression : Sendable {
}

extension Measurement : IntentValueConvertible {
}

extension Never : IntentValueConvertible {
}

extension Optional : IntentValueConvertible where Wrapped : IntentValueConvertible {

    /// Creates a container that represents this optional intent value.
    ///
    /// If the optional is `nil`, it creates a container that resolves to a null vlaue. If the optional isn't `nil`,
    /// it delegates the conversation to the wrapped value's container creation.
    ///
    /// - Parameter context: The context to use for the conversion.
    ///
    /// - Returns: An intent value container representing this optional value.
    public func makeContainer(context: IntentValueContainer.ConversionContext) -> IntentValueContainer
}

extension Optional : IntentValueExpressing where Wrapped : IntentValueExpressing {

    /// Creates an expression that represents this optional intent value.
    ///
    /// This method handles both the `.some` and `.none` cases:
    /// - For `.none`, it creates a pending expression that will resolve to a null value
    /// - For `.some`, it delegates to the wrapped value's expression creation
    ///
    /// - Returns: An intent value expression representing this optional value.
    public func makeExpression() -> IntentValueExpression
}

extension PersonNameComponents : IntentValueConvertible {
}

extension Set : IntentValueConvertible where Element : IntentValueConvertible {

    /// Creates a container that represents this set of intent values.
    ///
    /// This method converts each element in the set to its container representation
    /// and wraps them in an `ArrayContainerElement`.
    ///
    /// - Parameter context: The context to use for the conversion.
    /// - Returns: An intent value container representing this set.
    public func makeContainer(context: IntentValueContainer.ConversionContext) -> IntentValueContainer
}

extension Set : IntentValueExpressing where Element : IntentValueConvertible {

    /// Creates a pending expression of a set of intent values.
    ///
    /// The system evaluates the expression when needed,
    /// allowing for lazy conversion of the set's elements.
    ///
    /// - Returns: An intent value expression representing this set.
    public func makeExpression() -> IntentValueExpression
}

extension String : IntentValueConvertible {
}

extension URL : IntentValueConvertible {
}