What's new in AppIntents

public struct AppEntityContext : Hashable, Sendable {

    /// 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: AppEntityContext, b: AppEntityContext) -> 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 AppEntityContext {

    /// An audio-related context.
    ///
    /// - Parameter audioContext: The specific ``AudioContext`` describing
    ///   the audio activity for this donation.
    public static func audio(_ audioContext: AudioContext) -> AppEntityContext
}

extension AppSchema.AppStoreEntity {

    /**
    A schema that provides the system with a structured representation for
    a marketplace application entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `appStore` domain and its content matches the `marketplaceApplication` schema,
    use the `@AppEntity( .appStore.marketplaceApplication)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `marketplaceApplication` schema:
    
    ```swift
    @AppEntity(schema: .appStore.marketplaceApplication)
    struct MarketplaceApplication {
        // MARK: Static
    
        static let defaultQuery = MarketplaceApplicationQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var name: String
        var bundleID: String?
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct MarketplaceApplicationQuery: EntityQuery {
            func entities(for identifiers: [MarketplaceApplication.ID]) async throws -> [MarketplaceApplication] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var marketplaceApplication: some AppSchemaEntity { get }
}

extension AppSchema.AppStoreIntent {

    /**
    A schema that provides a structured representation for an intent that initiates the install process for a concrete application from an app
    marketplace.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `appStore` domain
    and one of your app’s actions matches the `installApplication` schema,
    use the `@AppIntent( .appStore.installApplication)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `installApplication` schema:
    
    ```swift
    @AppIntent(schema: .appStore.installApplication)
    struct InstallApplicationIntent {
        var application: <#MarketplaceApplication#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var installApplication: some AppSchemaIntent { get }
}

extension AppSchema.AudioEntity {

    /**
    A schema that provides the system with a structured representation for
    an album entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `audio` domain and its content matches the `album` schema,
    use the `@AppEntity( .audio.album)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `album` schema:
    
    ```swift
    @AppEntity(schema: .audio.album)
    struct AlbumEntity {
        // MARK: Static
    
        static let defaultQuery = AlbumEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var title: String
        var artistName: String
        var artists: [<#ArtistEntity#>]
        var universalProductCode: String?
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct AlbumEntityQuery: EntityQuery {
            func entities(for identifiers: [AlbumEntity.ID]) async throws -> [AlbumEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var album: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    an algorithmic radio station entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `audio` domain and its content matches the `algorithmicRadioStation` schema,
    use the `@AppEntity( .audio.algorithmicRadioStation)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `algorithmicRadioStation` schema:
    
    ```swift
    @AppEntity(schema: .audio.algorithmicRadioStation)
    struct AlgorithmicRadioStationEntity {
        // MARK: Static
    
        static let defaultQuery = AlgorithmicRadioStationEntityQuery()
    
        // MARK: Properties

Truncated.

extension AppSchema.AudioEnum {

    /**
    A schema that provides the system with a structured representation for
    an app view identifier parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `audio` domain and
    an intent's static parameter type matches the `appViewIdentifier` schema,
    use the `@AppEnum( .audio.appViewIdentifier)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `appViewIdentifier` schema:
    
    ```swift
    @AppEnum(schema: .audio.appViewIdentifier)
    enum AudioAppViewIdentifier: String {
        case nowPlaying
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .nowPlaying: "NowPlaying"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var appViewIdentifier: some AppSchemaEnum { get }

    /**
    A schema that provides the system with a structured representation for
    an affinity state parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `audio` domain and
    an intent's static parameter type matches the `affinityState` schema,
    use the `@AppEnum( .audio.affinityState)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `affinityState` schema:
    
    ```swift
    @AppEnum(schema: .audio.affinityState)
    enum AffinityState: String {
        case like
        case dislike
        case unset
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .like: "Like",
            .dislike: "Dislike",
            .unset: "Unset"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,

Truncated.

extension AppSchema.AudioIntent {

    /**
    A schema that provides a structured representation for an intent that adds an audio item to the user’s library.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `audio` domain
    and one of your app’s actions matches the `addToLibrary` schema,
    use the `@AppIntent( .audio.addToLibrary)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `addToLibrary` schema:
    
    ```swift
    @AppIntent(schema: .audio.addToLibrary)
    struct AddAudioToLibraryIntent {
        var audioEntity: <#UnionValue#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var addToLibrary: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that adds an audio item to a playlist.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `audio` domain
    and one of your app’s actions matches the `addToPlaylist` schema,
    use the `@AppIntent( .audio.addToPlaylist)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `addToPlaylist` schema:
    
    ```swift
    @AppIntent(schema: .audio.addToPlaylist)
    struct AddAudioToPlaylistIntent {
        var audioEntity: <#UnionValue#>
        var playlist: <#PlaylistEntity#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var addToPlaylist: some AppSchemaIntent { get }

    /**

Truncated.

extension AppSchema.BrowserEntity {

    /**
    A schema that provides the system with a structured representation for
    a tab group entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `browser` domain and its content matches the `tabGroup` schema,
    use the `@AppEntity( .browser.tabGroup)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `tabGroup` schema:
    
    ```swift
    @AppEntity(schema: .browser.tabGroup)
    struct TabGroupEntity {
        // MARK: Static
    
        static let defaultQuery = TabGroupEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var title: String
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct TabGroupEntityQuery: EntityQuery {
            func entities(for identifiers: [TabGroupEntity.ID]) async throws -> [TabGroupEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var tabGroup: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    a reading list item entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `browser` domain and its content matches the `readingListItem` schema,
    use the `@AppEntity( .browser.readingListItem)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `readingListItem` schema:
    
    ```swift
    @AppEntity(schema: .browser.readingListItem)
    struct ReadingListItemEntity {
        // MARK: Static
    
        static let defaultQuery = ReadingListItemEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>

Truncated.

extension AppSchema.CalendarEntity {

    /**
    A schema that provides the system with a structured representation for
    an attendee entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `calendar` domain and its content matches the `attendee` schema,
    use the `@AppEntity( .calendar.attendee)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `attendee` schema:
    
    ```swift
    @AppEntity(schema: .calendar.attendee)
    struct AttendeeEntity {
        // MARK: Static
    
        static let defaultQuery = AttendeeEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var person: IntentPerson
        var status: <#ParticipantStatus#>?
        var isAttendanceOptional: Bool
        var type: <#AttendeeType#>?
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct AttendeeEntityQuery: EntityQuery {
            func entities(for identifiers: [AttendeeEntity.ID]) async throws -> [AttendeeEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var attendee: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    a calendar entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `calendar` domain and its content matches the `calendar` schema,
    use the `@AppEntity( .calendar.calendar)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `calendar` schema:
    
    ```swift
    @AppEntity(schema: .calendar.calendar)
    struct CalendarEntity {
        // MARK: Static
    
        static let defaultQuery = CalendarEntityQuery()
    
        // MARK: Properties

Truncated.

extension AppSchema.CalendarEnum {

    /**
    A schema that provides the system with a structured representation for
    an attendee type parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `calendar` domain and
    an intent's static parameter type matches the `attendeeType` schema,
    use the `@AppEnum( .calendar.attendeeType)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `attendeeType` schema:
    
    ```swift
    @AppEnum(schema: .calendar.attendeeType)
    enum AttendeeType: String {
        case <#AttendeeType Case#>
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            <#DisplayRepresentations#>
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var attendeeType: some AppSchemaEnum { get }

    /**
    A schema that provides the system with a structured representation for
    an event status parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `calendar` domain and
    an intent's static parameter type matches the `eventStatus` schema,
    use the `@AppEnum( .calendar.eventStatus)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `eventStatus` schema:
    
    ```swift
    @AppEnum(schema: .calendar.eventStatus)
    enum EventEntityStatus: String {
        case confirmed
        case tentative
        case cancelled
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .confirmed: "Confirmed",
            .tentative: "Tentative",
            .cancelled: "Cancelled"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,

Truncated.

extension AppSchema.CalendarIntent {

    /**
    A schema that provides a structured representation for an intent that creates a calendar event.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `calendar` domain
    and one of your app’s actions matches the `createEvent` schema,
    use the `@AppIntent( .calendar.createEvent)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `createEvent` schema:
    
    ```swift
    @AppIntent(schema: .calendar.createEvent)
    struct CreateEventIntent {
        var title: String
        var startDate: Date
        var endDate: Date?
        var location: <#UnionValue#>?
        var calendar: <#CalendarEntity#>
        var isAllDay: Bool
        var recurrence: Calendar.RecurrenceRule?
        var attendees: [<#AttendeeEntity#>]
        var note: AttributedString?
    
        func perform() async throws -> some ReturnsValue<<#EventEntity#>> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var createEvent: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that deletes a calendar event.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `calendar` domain
    and one of your app’s actions matches the `deleteEvents` schema,
    use the `@AppIntent( .calendar.deleteEvents)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `deleteEvents` schema:
    
    ```swift
    @AppIntent(schema: .calendar.deleteEvents)
    struct DeleteEventIntent {
        var entity: <#EventEntity#>
        var span: <#EventSpan#>?
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri

Truncated.

extension AppSchema.ClockEntity {

    /**
    A schema that provides the system with a structured representation for
    an alarm entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `clock` domain and its content matches the `alarm` schema,
    use the `@AppEntity( .clock.alarm)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `alarm` schema:
    
    ```swift
    @AppEntity(schema: .clock.alarm)
    struct AlarmEntity {
        // MARK: Static
    
        static let defaultQuery = AlarmEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var time: DateComponents
        var isEnabled: Bool
        var label: String?
        var recurrenceDays: Calendar.RecurrenceRule?
        var canSnooze: Bool
        var triggerState: <#AlarmTriggerState#>
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct AlarmEntityQuery: EntityQuery {
            func entities(for identifiers: [AlarmEntity.ID]) async throws -> [AlarmEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var alarm: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    a stopwatch entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `clock` domain and its content matches the `stopwatch` schema,
    use the `@AppEntity( .clock.stopwatch)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `stopwatch` schema:
    
    ```swift
    @AppEntity(schema: .clock.stopwatch)
    struct StopwatchEntity {
        // MARK: Static
    
        static let defaultQuery = StopwatchEntityQuery()

Truncated.

extension AppSchema.ClockEnum {

    /**
    A schema that provides the system with a structured representation for
    an alarm trigger state parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `clock` domain and
    an intent's static parameter type matches the `alarmTriggerState` schema,
    use the `@AppEnum( .clock.alarmTriggerState)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `alarmTriggerState` schema:
    
    ```swift
    @AppEnum(schema: .clock.alarmTriggerState)
    enum AlarmTriggerState: String {
        case firing
        case snoozed
        case none
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .firing: "Firing",
            .snoozed: "Snoozed",
            .none: "None"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var alarmTriggerState: some AppSchemaEnum { get }

    /**
    A schema that provides the system with a structured representation for
    a timer state parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `clock` domain and
    an intent's static parameter type matches the `timerState` schema,
    use the `@AppEnum( .clock.timerState)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `timerState` schema:
    
    ```swift
    @AppEnum(schema: .clock.timerState)
    enum TimerState: String {
        case firing
        case paused
        case running
        case undefined
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .firing: "Firing",
            .paused: "Paused",
            .running: "Running",
            .undefined: "Undefined"
        ]
    }
    ```

Truncated.

extension AppSchema.ClockIntent {

    /**
    A schema that provides a structured representation for an intent that cancels timers.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `clock` domain
    and one of your app’s actions matches the `cancelTimer` schema,
    use the `@AppIntent( .clock.cancelTimer)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `cancelTimer` schema:
    
    ```swift
    @AppIntent(schema: .clock.cancelTimer)
    struct CancelTimerIntent {
        var entities: [<#TimerEntity#>]
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var cancelTimer: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that creates an alarm.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `clock` domain
    and one of your app’s actions matches the `createAlarm` schema,
    use the `@AppIntent( .clock.createAlarm)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `createAlarm` schema:
    
    ```swift
    @AppIntent(schema: .clock.createAlarm)
    struct CreateAlarmIntent {
        var time: DateComponents
        var label: String?
        var recurrenceDays: Calendar.RecurrenceRule?
        var canSnooze: Bool
    
        func perform() async throws -> some ReturnsValue<<#AlarmEntity#>> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var createAlarm: some AppSchemaIntent { get }

Truncated.

extension AppSchema.Entity : AppSchema.MessagesEntity {
}

extension AppSchema.Entity : AppSchema.ImageGenerationEntity {
}

extension AppSchema.Entity : AppSchema.AudioEntity {
}

extension AppSchema.Entity : AppSchema.RemindersEntity {
}

extension AppSchema.Entity : AppSchema.ClockEntity {
}

extension AppSchema.Entity : AppSchema.NotesEntity {
}

extension AppSchema.Entity : AppSchema.CalendarEntity {
}

extension AppSchema.Entity : AppSchema.PhoneEntity {
}

extension AppSchema.Entity : AppSchema.MapsEntity {
}

extension AppSchema.Entity : AppSchema.AppStoreEntity {
}

extension AppSchema.Enum : AppSchema.MessagesEnum {
}

extension AppSchema.Enum : AppSchema.ImageGenerationEnum {
}

extension AppSchema.Enum : AppSchema.AudioEnum {
}

extension AppSchema.Enum : AppSchema.RemindersEnum {
}

extension AppSchema.Enum : AppSchema.ClockEnum {
}

extension AppSchema.Enum : AppSchema.CalendarEnum {
}

extension AppSchema.Enum : AppSchema.PhoneEnum {
}

extension AppSchema.Enum : AppSchema.MapsEnum {
}

extension AppSchema.FilesIntent {

    /**
    A schema that provides a structured representation for an intent that scans a document.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `files` domain
    and one of your app’s actions matches the `showDocumentScanner` schema,
    use the `@AppIntent( .files.showDocumentScanner)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `showDocumentScanner` schema:
    
    ```swift
    @AppIntent(schema: .files.showDocumentScanner)
    struct ScanDocument {
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var showDocumentScanner: some AppSchemaIntent { get }
}

extension AppSchema.ImageGenerationEntity {

    /**
    A schema that provides the system with a structured representation for
    a style entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `imageGeneration` domain and its content matches the `style` schema,
    use the `@AppEntity( .imageGeneration.style)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `style` schema:
    
    ```swift
    @AppEntity(schema: .imageGeneration.style)
    struct ImageGenerationStyle {
        // MARK: Static
    
        static let defaultQuery = ImageGenerationStyleQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct ImageGenerationStyleQuery: EntityQuery {
            func entities(for identifiers: [ImageGenerationStyle.ID]) async throws -> [ImageGenerationStyle] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var style: some AppSchemaEntity { get }
}

extension AppSchema.ImageGenerationEnum {

    /**
    A schema that provides the system with a structured representation for
    a save to library mode parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `imageGeneration` domain and
    an intent's static parameter type matches the `saveToLibraryMode` schema,
    use the `@AppEnum( .imageGeneration.saveToLibraryMode)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `saveToLibraryMode` schema:
    
    ```swift
    @AppEnum(schema: .imageGeneration.saveToLibraryMode)
    enum ImageGenerationSaveMode: String {
        case always
        case askWhenRun
        case never
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .always: "Always",
            .askWhenRun: "AskWhenRun",
            .never: "Never"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var saveToLibraryMode: some AppSchemaEnum { get }
}

extension AppSchema.ImageGenerationIntent {

    /**
    A schema that provides a structured representation for an intent that generates an image with the specified prompt.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `imageGeneration` domain
    and one of your app’s actions matches the `generate` schema,
    use the `@AppIntent( .imageGeneration.generate)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `generate` schema:
    
    ```swift
    @AppIntent(schema: .imageGeneration.generate)
    struct ImageGenerationGenerateIntent {
        var prompt: String?
        var style: <#ImageGenerationStyle#>
        var image: IntentFile?
        var saveToLibrary: <#ImageGenerationSaveMode#>
    
        func perform() async throws -> some ReturnsValue<IntentFile> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var generate: some AppSchemaIntent { get }
}

extension AppSchema.Intent : AppSchema.MessagesIntent {
}

extension AppSchema.Intent : AppSchema.ImageGenerationIntent {
}

extension AppSchema.Intent : AppSchema.AudioIntent {
}

extension AppSchema.Intent : AppSchema.RemindersIntent {
}

extension AppSchema.Intent : AppSchema.ClockIntent {
}

extension AppSchema.Intent : AppSchema.NotesIntent {
}

extension AppSchema.Intent : AppSchema.CalendarIntent {
}

extension AppSchema.Intent : AppSchema.PhoneIntent {
}

extension AppSchema.Intent : AppSchema.MapsIntent {
}

extension AppSchema.Intent : AppSchema.AppStoreIntent {
}

extension AppSchema.Intent : AppSchema.VisualIntelligenceIntent {
}

extension AppSchema.MailEntity {

    /**
    A schema that provides the system with a structured representation for
    a thread entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `mail` domain and its content matches the `thread` schema,
    use the `@AppEntity( .mail.thread)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `thread` schema:
    
    ```swift
    @AppEntity(schema: .mail.thread)
    struct MailThreadEntity {
        // MARK: Static
    
        static let defaultQuery = MailThreadEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var title: String
        var description: String?
        var messages: [<#MailMessageEntity#>]
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct MailThreadEntityQuery: EntityQuery {
            func entities(for identifiers: [MailThreadEntity.ID]) async throws -> [MailThreadEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var thread: some AppSchemaEntity { get }
}

extension AppSchema.MailIntent {

    /**
    An intent schema that opens an email draft.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `mail` domain
    and one of your app’s actions matches the `openDraft` schema,
    use the `@AppIntent( .mail.openDraft)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `openDraft` schema:
    
    ```swift
    @AppIntent(schema: .mail.openDraft)
    struct MailOpenDraft: OpenIntent {
        var target: <#MailDraftEntity#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var openDraft: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that opens an email message.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `mail` domain
    and one of your app’s actions matches the `openMessage` schema,
    use the `@AppIntent( .mail.openMessage)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `openMessage` schema:
    
    ```swift
    @AppIntent(schema: .mail.openMessage)
    struct MailOpenMessage: OpenIntent {
        var target: <#MailMessageEntity#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var openMessage: some AppSchemaIntent { get }
}

extension AppSchema.MapsEntity {

    /**
    A schema that provides the system with a structured representation for
    a current location entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `maps` domain and its content matches the `currentLocation` schema,
    use the `@AppEntity( .maps.currentLocation)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `currentLocation` schema:
    
    ```swift
    @AppEntity(schema: .maps.currentLocation)
    struct MapsCurrentLocationEntity {
        // MARK: Static
    
        static let defaultQuery = MapsCurrentLocationEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct MapsCurrentLocationEntityQuery: EntityQuery {
            func entities(for identifiers: [MapsCurrentLocationEntity.ID]) async throws -> [MapsCurrentLocationEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var currentLocation: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    a navigation session entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `maps` domain and its content matches the `navigationSession` schema,
    use the `@AppEntity( .maps.navigationSession)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `navigationSession` schema:
    
    ```swift
    @AppEntity(schema: .maps.navigationSession)
    struct MapsNavigationSessionEntity: UniqueEntity {
        // MARK: Static
    
        static let defaultQuery = MapsNavigationSessionEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var estimatedArrivalDate: Date
        var waypoints: [<#MapsLocation#>]

Truncated.

extension AppSchema.MapsEnum {

    /**
    A schema that provides the system with a structured representation for
    an incident parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `maps` domain and
    an intent's static parameter type matches the `incident` schema,
    use the `@AppEnum( .maps.incident)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `incident` schema:
    
    ```swift
    @AppEnum(schema: .maps.incident)
    enum MapsIncidentEnum: String {
        case <#MapsIncidentEnum Case#>
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            <#DisplayRepresentations#>
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var incident: some AppSchemaEnum { get }

    /**
    A schema that provides the system with a structured representation for
    a navigation preferences parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `maps` domain and
    an intent's static parameter type matches the `navigationPreferences` schema,
    use the `@AppEnum( .maps.navigationPreferences)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `navigationPreferences` schema:
    
    ```swift
    @AppEnum(schema: .maps.navigationPreferences)
    enum MapsNavigationPreferencesEnum: String {
        case <#MapsNavigationPreferencesEnum Case#>
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            <#DisplayRepresentations#>
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var navigationPreferences: some AppSchemaEnum { get }

Truncated.

extension AppSchema.MapsIntent {

    /**
    A schema that provides a structured representation for an intent that shares ETA to a contact while navigating.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `maps` domain
    and one of your app’s actions matches the `shareETA` schema,
    use the `@AppIntent( .maps.shareETA)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `shareETA` schema:
    
    ```swift
    @AppIntent(schema: .maps.shareETA)
    struct MapsShareETAIntent {
        var person: IntentPerson
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var shareETA: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that starts navigation.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `maps` domain
    and one of your app’s actions matches the `startNavigation` schema,
    use the `@AppIntent( .maps.startNavigation)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `startNavigation` schema:
    
    ```swift
    @AppIntent(schema: .maps.startNavigation)
    struct MapsStartNavigationIntent {
        var transportationType: <#MapsTransportTypeEnum#>
        var origin: <#MapsLocation#>
        var destinations: [<#MapsLocation#>]
        var preferences: Set<<#MapsNavigationPreferencesEnum#>>
    
        func perform() async throws -> some ReturnsValue<<#MapsNavigationSessionEntity#>?> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var startNavigation: some AppSchemaIntent { get }

Truncated.

extension AppSchema.MessagesEntity {

    /**
    A schema that provides the system with a structured representation for
    a conversation entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `messages` domain and its content matches the `conversation` schema,
    use the `@AppEntity( .messages.conversation)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `conversation` schema:
    
    ```swift
    @AppEntity(schema: .messages.conversation)
    struct ConversationEntity {
        // MARK: Static
    
        static let defaultQuery = ConversationEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var recipients: [<#MessagePerson#>]
        var displayName: String
        var previewText: AttributedString
        var conversationName: String?
        var isRead: Bool
        var attributes: Set<<#ConversationAttribute#>>
        var dateLastActive: Date?
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct ConversationEntityQuery: EntityQuery {
            func entities(for identifiers: [ConversationEntity.ID]) async throws -> [ConversationEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var conversation: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    a custom attachment entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `messages` domain and its content matches the `customAttachment` schema,
    use the `@AppEntity( .messages.customAttachment)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `customAttachment` schema:
    
    ```swift
    @AppEntity(schema: .messages.customAttachment)
    struct CustomAttachment {
        // MARK: Static

Truncated.

extension AppSchema.MessagesEnum {

    /**
    A schema that provides the system with a structured representation for
    a conversation attribute parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `messages` domain and
    an intent's static parameter type matches the `conversationAttribute` schema,
    use the `@AppEnum( .messages.conversationAttribute)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `conversationAttribute` schema:
    
    ```swift
    @AppEnum(schema: .messages.conversationAttribute)
    enum ConversationAttribute: String {
        case <#ConversationAttribute Case#>
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            <#DisplayRepresentations#>
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var conversationAttribute: some AppSchemaEnum { get }

    /**
    A schema that provides the system with a structured representation for
    a message attribute parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `messages` domain and
    an intent's static parameter type matches the `messageAttribute` schema,
    use the `@AppEnum( .messages.messageAttribute)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `messageAttribute` schema:
    
    ```swift
    @AppEnum(schema: .messages.messageAttribute)
    enum MessageAttribute: String {
        case <#MessageAttribute Case#>
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            <#DisplayRepresentations#>
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var messageAttribute: some AppSchemaEnum { get }

Truncated.

extension AppSchema.MessagesIntent {

    /**
    A schema that provides a structured representation for an intent that edits an already sent message with new content.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `messages` domain
    and one of your app’s actions matches the `editSentMessage` schema,
    use the `@AppIntent( .messages.editSentMessage)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `editSentMessage` schema:
    
    ```swift
    @AppIntent(schema: .messages.editSentMessage)
    struct EditSentMessageIntent {
        var message: <#MessageEntity#>
        var content: AttributedString
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var editSentMessage: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that sends a message with the associated parameters.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `messages` domain
    and one of your app’s actions matches the `sendMessage` schema,
    use the `@AppIntent( .messages.sendMessage)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `sendMessage` schema:
    
    ```swift
    @AppIntent(schema: .messages.sendMessage)
    struct SendMessageIntent {
        var content: AttributedString?
        var destination: <#UnionValue#>
        var subject: AttributedString?
        var attachments: [IntentFile]
        var audioMessage: IntentFile?
        var locations: [GeoToolbox.PlaceDescriptor]
        var links: [URL]
        var scheduledDate: Date?
    
        func perform() async throws -> some ReturnsValue<[<#MessageEntity#>]> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts

Truncated.

extension AppSchema.NotesEntity {

    /**
    A schema that provides the system with a structured representation for
    a note entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `notes` domain and its content matches the `note` schema,
    use the `@AppEntity( .notes.note)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `note` schema:
    
    ```swift
    @AppEntity(schema: .notes.note)
    struct NoteEntity {
        // MARK: Static
    
        static let defaultQuery = NoteEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var name: AttributedString
        var content: AttributedString?
        var attachments: [IntentFile]
        var tags: [<#TagEntity#>]
        var isPinned: Bool
        var creationDate: Date?
        var modificationDate: Date?
        var folder: <#FolderEntity#>?
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct NoteEntityQuery: EntityQuery {
            func entities(for identifiers: [NoteEntity.ID]) async throws -> [NoteEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var note: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    a tag entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `notes` domain and its content matches the `tag` schema,
    use the `@AppEntity( .notes.tag)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `tag` schema:
    
    ```swift
    @AppEntity(schema: .notes.tag)
    struct TagEntity {
        // MARK: Static

Truncated.

extension AppSchema.NotesIntent {

    /**
    A schema that provides a structured representation for an intent that creates a new note.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `notes` domain
    and one of your app’s actions matches the `createNote` schema,
    use the `@AppIntent( .notes.createNote)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `createNote` schema:
    
    ```swift
    @AppIntent(schema: .notes.createNote)
    struct CreateNoteIntent {
        var name: String
        var content: AttributedString?
        var attachments: [IntentFile]
        var tags: [<#TagEntity#>]
        var isPinned: Bool
        var folder: <#FolderEntity#>?
    
        func perform() async throws -> some ReturnsValue<<#NoteEntity#>> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var createNote: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that updates a note.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `notes` domain
    and one of your app’s actions matches the `updateNote` schema,
    use the `@AppIntent( .notes.updateNote)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `updateNote` schema:
    
    ```swift
    @AppIntent(schema: .notes.updateNote)
    struct UpdateNoteIntent {
        var target: <#NoteEntity#>
        var name: String?
        var attachments: [IntentFile]?
        var tags: [<#TagEntity#>]?
        var isPinned: Bool?
        var folder: <#FolderEntity#>?
    
        func perform() async throws -> some ReturnsValue<<#NoteEntity#>> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients

Truncated.

extension AppSchema.PhoneEntity {

    /**
    A schema that provides the system with a structured representation for
    a phone person entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `phone` domain and its content matches the `phonePerson` schema,
    use the `@AppEntity( .phone.phonePerson)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `phonePerson` schema:
    
    ```swift
    @AppEntity(schema: .phone.phonePerson)
    struct PhonePerson {
        // MARK: Static
    
        static let defaultQuery = PhonePersonQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var person: IntentPerson
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct PhonePersonQuery: EntityQuery {
            func entities(for identifiers: [PhonePerson.ID]) async throws -> [PhonePerson] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var phonePerson: some AppSchemaEntity { get }
}

extension AppSchema.PhoneEnum {

    /**
    A schema that provides the system with a structured representation for
    an audio visual mode parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `phone` domain and
    an intent's static parameter type matches the `audioVisualMode` schema,
    use the `@AppEnum( .phone.audioVisualMode)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `audioVisualMode` schema:
    
    ```swift
    @AppEnum(schema: .phone.audioVisualMode)
    enum CallAVMode: String {
        case audio
        case video
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .audio: "Audio",
            .video: "Video"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var audioVisualMode: some AppSchemaEnum { get }
}

extension AppSchema.PhoneIntent {

    /**
    A schema that provides a structured representation for an intent that starts a call to a person, handle, or named group.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `phone` domain
    and one of your app’s actions matches the `startCall` schema,
    use the `@AppIntent( .phone.startCall)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `startCall` schema:
    
    ```swift
    @AppIntent(schema: .phone.startCall)
    struct StartCallIntent: AudioRecordingIntent, AudioStartingIntent {
        var destination: <#UnionValue#>
        var audioVisualMode: <#CallAVMode#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var startCall: some AppSchemaIntent { get }
}

extension AppSchema.PhotosEntity {

    /**
    A schema that provides the system with a structured representation for
    an asset entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `photos` domain and its content matches the `asset` schema,
    use the `@AppEntity( .photos.asset)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `asset` schema:
    
    ```swift
    @AppEntity(schema: .photos.asset)
    struct PhotoEntity {
        // MARK: Static
    
        static let defaultQuery = PhotoEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var creationDate: Date?
        var location: GeoToolbox.PlaceDescriptor?
        var assetType: <#PhotoAssetType#>?
        var isFavorite: Bool
        var isHidden: Bool
        var hasSuggestedEdits: Bool
        var aperture: Double?
        var exposure: Double?
        var saturation: Double?
        var warmth: Double?
        var filter: <#PhotoFilterEffectType#>?
        var isPortraitModeEnabled: Bool?
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct PhotoEntityQuery: EntityQuery {
            func entities(for identifiers: [PhotoEntity.ID]) async throws -> [PhotoEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var asset: some AppSchemaEntity { get }
}

extension AppSchema.PhotosIntent {

    /**
    A schema that provides a structured representation for an intent that opens the specified photo to edit.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `photos` domain
    and one of your app’s actions matches the `editAsset` schema,
    use the `@AppIntent( .photos.editAsset)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `editAsset` schema:
    
    ```swift
    @AppIntent(schema: .photos.editAsset)
    struct EditAsset {
        var asset: <#PhotoEntity#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var editAsset: some AppSchemaIntent { get }
}

extension AppSchema.RemindersEntity {

    /**
    A schema that provides the system with a structured representation for
    a group entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `reminders` domain and its content matches the `group` schema,
    use the `@AppEntity( .reminders.group)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `group` schema:
    
    ```swift
    @AppEntity(schema: .reminders.group)
    struct GroupEntity {
        // MARK: Static
    
        static let defaultQuery = GroupEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>
    
        var name: String
        var lists: [<#ListEntity#>]
    
        var displayRepresentation: DisplayRepresentation {
            <#DisplayRepresentation#>
        }
    
        // MARK: Query
    
        struct GroupEntityQuery: EntityQuery {
            func entities(for identifiers: [GroupEntity.ID]) async throws -> [GroupEntity] {
                <#code#>
            }
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var group: some AppSchemaEntity { get }

    /**
    A schema that provides the system with a structured representation for
    a list entity.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your content. An ``AppEntity`` that conforms to a schema provides this structured
    representation. If your app's functionality aligns with the `reminders` domain and its content matches the `list` schema,
    use the `@AppEntity( .reminders.list)` Swift macro to automatically generate required properties and add protocol conformance
    to your app entity implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app entity that conforms to the `list` schema:
    
    ```swift
    @AppEntity(schema: .reminders.list)
    struct ListEntity {
        // MARK: Static
    
        static let defaultQuery = ListEntityQuery()
    
        // MARK: Properties
    
        let id: <#Identifiable.ID#>

Truncated.

extension AppSchema.RemindersEnum {

    /**
    A schema that provides the system with a structured representation for
    a list type parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `reminders` domain and
    an intent's static parameter type matches the `listType` schema,
    use the `@AppEnum( .reminders.listType)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `listType` schema:
    
    ```swift
    @AppEnum(schema: .reminders.listType)
    enum ListType: String {
        case standard
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .standard: "Standard"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var listType: some AppSchemaEnum { get }

    /**
    A schema that provides the system with a structured representation for
    a location trigger event parameter.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of each static intent parameter type. An ``AppEnum`` that conforms to a schema
    provides this structured representation. If your app's functionality aligns with the `reminders` domain and
    an intent's static parameter type matches the `locationTriggerEvent` schema,
    use the `@AppEnum( .reminders.locationTriggerEvent)` Swift macro
    to automatically generate required
    protocol conformance for your app enum implementation.
    Then, integrate your app with Siri and Apple Intelligence as
    described in <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an app enum that conforms to the `locationTriggerEvent` schema:
    
    ```swift
    @AppEnum(schema: .reminders.locationTriggerEvent)
    enum LocationTriggerEvent: String {
        case arrive
        case depart
    
        static let caseDisplayRepresentations: [Self: DisplayRepresentation] = [
            .arrive: "Arrive",
            .depart: "Depart"
        ]
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */

Truncated.

extension AppSchema.RemindersIntent {

    /**
    A schema that provides a structured representation for an intent that creates a new reminder list.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `reminders` domain
    and one of your app’s actions matches the `createList` schema,
    use the `@AppIntent( .reminders.createList)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `createList` schema:
    
    ```swift
    @AppIntent(schema: .reminders.createList)
    struct CreateListIntent {
        var name: String?
        var type: <#ListType#>
    
        func perform() async throws -> some ReturnsValue<<#ListEntity#>> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var createList: some AppSchemaIntent { get }

    /**
    A schema that provides a structured representation for an intent that creates a new reminder.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `reminders` domain
    and one of your app’s actions matches the `createReminder` schema,
    use the `@AppIntent( .reminders.createReminder)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `createReminder` schema:
    
    ```swift
    @AppIntent(schema: .reminders.createReminder)
    struct CreateReminderIntent {
        var title: String
        var list: <#ListEntity#>?
        var note: AttributedString?
        var isFlagged: Bool?
        var images: [IntentFile]
        var tags: Set<String>
        var urls: [URL]
        var dueDate: DateComponents?
        var recurrence: Calendar.RecurrenceRule?
        var locationTrigger: <#LocationTriggerEntity#>?
        var section: <#SectionEntity#>?
    
        func perform() async throws -> some ReturnsValue<<#ReminderEntity#>> {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients

Truncated.

extension AppSchema.SystemIntent {

    /**
    A schema that provides a structured representation for an intent that opens the specified item in the application.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `system` domain
    and one of your app’s actions matches the `open` schema,
    use the `@AppIntent( .system.open)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `open` schema:
    
    ```swift
    @AppIntent(schema: .system.open)
    struct OpenIntent: OpenIntent {
        var target: <#any AppEntity#>
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Siri
    - Shortcuts
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var open: some AppSchemaIntent { get }
}

extension AppSchema.VisualIntelligenceIntent {

    /**
    A schema that provides a structured representation for an intent that shows more and richer visual search results in the app.
    
    ## Overview
    
    To integrate your app’s functionality with Siri and Apple Intelligence,
    the system needs a structured representation of your app's action.
    An ``AppIntent`` that conforms to a schema provides this
    structured representation. If your app's functionality aligns with the `visualIntelligence` domain
    and one of your app’s actions matches the `semanticContentSearch` schema,
    use the `@AppIntent( .visualIntelligence.semanticContentSearch)` Swift macro
    to automatically generate required properties and add protocol conformance
    to your intent implementation. Then, integrate your app with Siri and Apple Intelligence as described in
    <doc://com.apple.documentation/documentation/appintents/siri-and-apple-intelligence>.
    
    The following example shows an intent that conforms to the `semanticContentSearch` schema:
    
    ```swift
    @AppIntent(schema: .visualIntelligence.semanticContentSearch)
    struct ShowVisualSearchResultsInAppIntent {
        var semanticContent: VisualIntelligence.SceneDescriptor
    
        func perform() async throws -> some IntentResult {
            <#code#>
        }
    }
    ```
    
    ## Supported Clients
    
    - Shortcuts
    - Visual Intelligence
    
    For general information about the App Intents framework and the system experiences it enables,
    see <doc://com.apple.documentation/documentation/appintents/Making-actions-and-content-discoverable-and-widely-available>.
    */
    public var semanticContentSearch: some AppSchemaIntent { get }
}

extension AppSchemaEnum where Self == AppSchema.Enum {

    /// App enum schema conformance for types you use for maps functionality.
    public static var maps: some AppSchema.MapsEnum { get }
}

public protocol AppUnionValue : TypeDisplayRepresentable {

    /// The nominal type representing the cases of this union value.
    ///
    /// This associated type is automatically generated by the `@UnionValue` macro
    /// as an enum conforming to `AppUnionValueCasesProviding`.
    associatedtype Cases : AppUnionValueCasesProviding where Self == Self.Cases.UnionValue

    /// A dictionary that maps each case to the visual elements that represent it.
    static var caseDisplayRepresentations: [Self.Cases : DisplayRepresentation] { get }
}

extension AppUnionValue {

    /// Default implementation providing an empty type display representation.
    public static var typeDisplayRepresentation: TypeDisplayRepresentation { get }

    /// Default implementation providing an empty case display representations dictionary.
    public static var caseDisplayRepresentations: [Self.Cases : DisplayRepresentation] { get }
}

public protocol AppUnionValueCasesProviding : AppEnum {

    /// The union value type that this cases enum represents.
    associatedtype UnionValue : AppUnionValue where Self == Self.UnionValue.Cases
}

extension AppUnionValueCasesProviding {

    /// Inherits type display representation from the associated union value type.
    public static var typeDisplayRepresentation: TypeDisplayRepresentation { get }

    /// Inherits case display representations from the associated union value type.
    public static var caseDisplayRepresentations: [Self : DisplayRepresentation] { get }
}

public struct AudioContext : Hashable, Sendable {

    /// The Now Playing control or complication.
    ///
    /// Use this to donate entities relevant to the Now Playing control or complication in the system.
    public static var nowPlaying: AudioContext { 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: AudioContext, b: AudioContext) -> 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 AudioContext {

    /// A workout session of any type.
    ///
    /// Use this to donate entities relevant to any workout,
    /// regardless of activity type or intensity.
    ///
    /// You can donate entities to multiple workout contexts simultaneously.
    /// More specific contexts (e.g., a specific activity type) give the system
    /// stronger hints than broader ones (e.g., any workout). The system
    /// considers all matching entities and their relevance when determining
    /// what to suggest.
    public static var workout: AudioContext { get }

    /// A workout session of the given activity type.
    ///
    /// - Parameter activityType: The type of workout in progress.
    public static func workout(activityType: HKWorkoutActivityType) -> AudioContext

    /// A workout session of the given intensity level.
    ///
    /// - Parameter intensityLevel: The intensity of the workout.
    public static func workout(intensityLevel: AudioContext.WorkoutIntensityLevel) -> AudioContext

    /// The intensity level of a workout session.
    ///
    /// Use this type to specify a workout intensity level when donating entities
    /// for workout contexts. You can also initialize it with an `HKWorkoutActivityType`
    /// to donate entities for a specific workout type.
    public struct WorkoutIntensityLevel : Hashable, Sendable {

        public let rawValue: UInt

        public init(rawValue: UInt)

        /// Creates an intensity level from an `HKWorkoutActivityType`.
        public init(_ workoutActivityType: HKWorkoutActivityType)

        /// A low-intensity workout such as yoga, stretching, or walking.
        public static let low: AudioContext.WorkoutIntensityLevel

        /// A medium-intensity workout such as cycling, hiking, or swimming.
        public static let medium: AudioContext.WorkoutIntensityLevel

        /// A high-intensity workout such as running, HIIT, or cross-training.
        public static let high: AudioContext.WorkoutIntensityLevel

        /// 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: AudioContext.WorkoutIntensityLevel, b: AudioContext.WorkoutIntensityLevel) -> 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

Truncated.

extension Calendar.RecurrenceRule : @retroactive IntentValueConvertible {
}

extension CSSearchableItem {

    /// The identifier of the related indexed entity for this searchable item.
    ///
    /// Convenience property that forwards to the item's attribute set.
    /// Use this property to associate a child searchable item such as
    /// an attachment or embedded content with its parent
    /// `IndexedEntity` instance.
    ///
    /// Only an identifier reference is stored. No entity content is
    /// embedded in the child item.
    ///
    /// Setting this property again replaces the previously set identifier.
    public var relatedAppEntityIdentifier: EntityIdentifier?
}

public protocol CustomAppIntentErrorConvertible {

    var appIntentError: AppIntentError { get }
}

extension CVReadOnlyPixelBuffer : @retroactive IntentValueConvertible {
}

extension CVReadOnlyPixelBuffer : @retroactive IntentValueExpressing {
}

extension CVReadOnlyPixelBuffer {

    public static var defaultResolverSpecification: EmptyResolverSpecification<CVReadOnlyPixelBuffer> { get }

    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Specification = EmptyResolverSpecification<CVReadOnlyPixelBuffer>

    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias UnwrappedType = CVReadOnlyPixelBuffer

    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias ValueType = CVReadOnlyPixelBuffer
}

public struct EntityCollection<Entity> : Equatable, Sendable where Entity : AppEntity {

    /// The entity identifiers in the collection.
    ///
    /// Use this property to retrieve the entity identifiers from the collection. You might use
    /// an identifier to retrieve an individual ``AppEntity`` instance from your app.
    public var identifiers: [Entity.ID]

    /// Creates a new entity identifier collection.
    ///
    /// - Parameters:
    ///    - identifiers: The entity identifiers to add to the collection.
    public init(identifiers: [Entity.ID] = [])

    /// Creates a new entity identifier collection from entities.
    ///
    /// - Parameters:
    ///    - entities: The entities to add to the collection.
    ///
    /// This initializer adds the identifier for each entity to the collection and caches the
    /// entity instances for fast retrieval later.
    public init(entities: [Entity])

    /// The number of entity identifiers in this collection.
    public var count: Int { get }

    /// A Boolean value that indicates whether the collection is empty.
    ///
    /// The value of this property is `true` if the collection is empty, or `false` if the
    /// collection has one or more identifiers.
    public var isEmpty: Bool { 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 == (lhs: EntityCollection<Entity>, rhs: EntityCollection<Entity>) -> Bool
}

extension EntityCollection {

    public typealias ValueType = Entity

    public typealias UnwrappedType = EntityCollection<Entity>

    public static var defaultResolverSpecification: some ResolverSpecification { get }

    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Specification = some ResolverSpecification
}

extension EntityCollection : Collection {

    /// The position of the first element in a nonempty collection.
    ///
    /// If the collection is empty, `startIndex` is equal to `endIndex`.
    public var startIndex: Int { get }

    /// The collection's "past the end" position---that is, the position one
    /// greater than the last valid subscript argument.
    ///
    /// When you need a range that includes the last element of a collection, use
    /// the half-open range operator (`..<`) with `endIndex`. The `..<` operator
    /// creates a range that doesn't include the upper bound, so it's always
    /// safe to use with `endIndex`. For example:
    ///
    ///     let numbers = [10, 20, 30, 40, 50]
    ///     if let index = numbers.firstIndex(of: 30) {
    ///         print(numbers[index ..< numbers.endIndex])
    ///     }
    ///     // Prints "[30, 40, 50]"
    ///
    /// If the collection is empty, `endIndex` is equal to `startIndex`.
    public var endIndex: Int { get }

    /// Accesses the element at the specified position.
    ///
    /// The following example accesses an element of an array through its
    /// subscript to print its value:
    ///
    ///     var streets = ["Adams", "Bryant", "Channing", "Douglas", "Evarts"]
    ///     print(streets[1])
    ///     // Prints "Bryant"
    ///
    /// You can subscript a collection with any valid index other than the
    /// collection's end index. The end index refers to the position one past
    /// the last element of a collection, so it doesn't correspond with an
    /// element.
    ///
    /// - Parameter position: The position of the element to access. `position`
    ///   must be a valid index of the collection that is not equal to the
    ///   `endIndex` property.
    ///
    /// - Complexity: O(1)
    public subscript(position: Int) -> Entity.ID { get }

    /// Returns the position immediately after the given index.
    ///
    /// The successor of an index must be well defined. For an index `i` into a
    /// collection `c`, calling `c.index(after: i)` returns the same index every
    /// time.
    ///
    /// - Parameter i: A valid index of the collection. `i` must be less than
    ///   `endIndex`.
    /// - Returns: The index value immediately after `i`.
    public func index(after i: Int) -> Int

    /// A type representing the sequence's elements.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Element = Entity.ID

    /// A type that represents a position in the collection.
    ///
    /// Valid indices consist of the position of every element and a
    /// "past the end" position that's not valid for use as a subscript
    /// argument.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Index = Int

    /// A type that represents the indices that are valid for subscripting the
    /// collection, in ascending order.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Indices = DefaultIndices<EntityCollection<Entity>>

    /// A type that provides the collection's iteration interface and
    /// encapsulates its iteration state.
    ///
    /// By default, a collection conforms to the `Sequence` protocol by
    /// supplying `IndexingIterator` as its associated `Iterator`
    /// type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)

Truncated.

extension EntityCollection : ExpressibleByArrayLiteral {

    /// Creates an instance initialized with the given elements.
    public init(arrayLiteral elements: Entity.ID...)

    /// The type of the elements of an array literal.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias ArrayLiteralElement = Entity.ID
}

public struct EntityOwnership : OptionSet, Sendable {

    /// The corresponding value of the raw type.
    ///
    /// A new instance initialized with `rawValue` will be equivalent to this
    /// instance. For example:
    ///
    ///     enum PaperSize: String {
    ///         case A4, A5, Letter, Legal
    ///     }
    ///
    ///     let selectedSize = PaperSize.Letter
    ///     print(selectedSize.rawValue)
    ///     // Prints "Letter"
    ///
    ///     print(selectedSize == PaperSize(rawValue: selectedSize.rawValue)!)
    ///     // Prints "true"
    public let rawValue: Int

    /// Creates a new option set from the given raw value.
    ///
    /// This initializer always succeeds, even if the value passed as `rawValue`
    /// exceeds the static properties declared as part of the option set. This
    /// example creates an instance of `ShippingOptions` with a raw value beyond
    /// the highest element, with a bit mask that effectively contains all the
    /// declared static members.
    ///
    ///     let extraOptions = ShippingOptions(rawValue: 255)
    ///     print(extraOptions.isStrictSuperset(of: .all))
    ///     // Prints "true"
    ///
    /// - Parameter rawValue: The raw value of the option set to create. Each bit
    ///   of `rawValue` potentially represents an element of the option set,
    ///   though raw values may include bits that are not defined as distinct
    ///   values of the `OptionSet` type.
    public init(rawValue: Int)

    /// A state that indicates that entity ownership or sharing status is unknown or unspecified.
    public static let unknown: EntityOwnership

    /// A state that indicates a person shares the entity with specific collaborators.
    public static let shared: EntityOwnership

    /// A state that indicates the entity represents data a person shares publicly.
    public static let `public`: EntityOwnership

    /// The type of the elements of an array literal.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias ArrayLiteralElement = EntityOwnership

    /// The element type of the option set.
    ///
    /// To inherit all the default implementations from the `OptionSet` protocol,
    /// the `Element` type must be `Self`, the default.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Element = EntityOwnership

    /// The raw type that can be used to represent all values of the conforming
    /// type.
    ///
    /// Every distinct value of the conforming type has a corresponding unique
    /// value of the `RawValue` type, but there may be values of the `RawValue`
    /// type that don't have a corresponding value of the conforming type.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias RawValue = Int
}

extension EntityProperty where Value.ValueType : AppEntity {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType : FileEntity {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType : AppEnum {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType : _IntentValueRepresentable {

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    public convenience init(identifier: String)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    public convenience init(identifier: String, title: LocalizedStringResource)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init(identifier: String, customIndexingKey: CSCustomAttributeKey)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - getter: The getter reference for the property
    public convenience init<Entity>(identifier: String, getter: KeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - getSetter: The getter reference for the property
    public convenience init<Entity>(identifier: String, getSetter: WritableKeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - asyncGetter: The getter reference for the property
    public convenience init<Entity>(identifier: String, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - getter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, getter: KeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - getSetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, getSetter: WritableKeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - getter: The getter reference for the property

Truncated.

extension EntityProperty where Value.ValueType : _SystemIntentValue {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType == AttributedString {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType == Bool {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType == CLPlacemark {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType : Decodable, Value.ValueType : Encodable {

    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType == CVReadOnlyPixelBuffer {

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    public convenience init(identifier: String)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    public convenience init(identifier: String, title: LocalizedStringResource)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init(identifier: String, customIndexingKey: CSCustomAttributeKey)

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - getter: The getter reference for the property
    public convenience init<Entity>(identifier: String, getter: KeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - getSetter: The getter reference for the property
    public convenience init<Entity>(identifier: String, getSetter: WritableKeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - asyncGetter: The getter reference for the property
    public convenience init<Entity>(identifier: String, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - getter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, getter: KeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - getSetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, getSetter: WritableKeyPath<Entity, Value>) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - getter: The getter reference for the property

Truncated.

extension EntityProperty where Value.ValueType == Date {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType == DateComponents {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType == Double {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty where Value.ValueType == Duration {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}

extension EntityProperty {

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    public convenience init<Entity>(identifier: String) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - getter: The getter reference for the property
    public convenience init<Entity>(identifier: String, getter: KeyPath<Entity, Value>) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - getSetter: The getter reference for the property
    public convenience init<Entity>(identifier: String, getSetter: WritableKeyPath<Entity, Value>) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - asyncGetter: The getter reference for the property
    public convenience init<Entity>(identifier: String, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - getter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, getter: KeyPath<Entity, Value>) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - getSetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, getSetter: WritableKeyPath<Entity, Value>) where Entity : AppEntity, Value.ValueType == EntityCollection<Entity>

    /// Creates an app intent entity property.  Do not call this directly, use @ComputedProperty or @DeferredProperty
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - getter: The getter reference for the property

Truncated.

extension EntityProperty where Value.ValueType == Int {

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - indexingKey: A Spotlight attribute set key mapping for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, indexingKey: PartialKeyPath<CSSearchableItemAttributeSet>, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity

    /// Creates an app intent entity property.  Do not call this directly, use @Property
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the property
    ///   - title: A word or short phrase summarizing this property.
    ///   - customIndexingKey: A custom Spotlight attribute set key for this property.
    ///   - asyncGetter: The getter reference for the property
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    public convenience init<Entity>(identifier: String, title: LocalizedStringResource, customIndexingKey: CSCustomAttributeKey, asyncGetter: @escaping @Sendable (Entity) async throws -> Value) where Entity : AppEntity
}