What's new in SwiftUI

public struct AnyNavigationTransition : NavigationTransition, ~Sendable {

    public init(_ transition: some NavigationTransition)
}

public struct CrossFadeNavigationTransition : NavigationTransition, Sendable {
}

@MainActor @preconcurrency public struct DefaultNewDocumentButtonLabel : View {

    @MainActor @preconcurrency public init()

    /// The content and behavior of the view.
    ///
    /// When you implement a custom view, you must implement a computed
    /// `body` property to provide the content for your view. Return a view
    /// that's composed of built-in views that SwiftUI provides, plus other
    /// composite views that you've already defined:
    ///
    ///     struct MyView: View {
    ///         var body: some View {
    ///             Text("Hello, World!")
    ///         }
    ///     }
    ///
    /// For more information about composing views and a view hierarchy,
    /// see <doc:Declaring-a-Custom-View>.
    @MainActor @preconcurrency public var body: some View { get }

    /// The type of view representing the body of this view.
    ///
    /// When you create a custom view, Swift infers this type from your
    /// implementation of the required ``View/body-swift.property`` property.
    @available(macOS 27.0, iOS 27.0, *)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    public typealias Body = some View
}

public struct DocumentCreationContext {

    /// The source associated with the button that created this document.
    ///
    /// On iOS, you can specify the source via ``NewDocumentButton`` in
    /// ``DocumentGroupLaunchScene``. On macOS, this is always `nil`.
    public var creationSource: DocumentCreationSource? { get }
}

extension DocumentCreationContext : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension DocumentCreationContext : Hashable, Equatable {

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

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

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

public struct DocumentCreationSource : Sendable, Hashable {

    /// A string that uniquely identifies this creation source within your app.
    public let id: String

    /// Creates a document creation source with the given identifier.
    ///
    /// Use different sources to distinguish between document creation flows
    /// in your app.
    ///
    ///     extension DocumentCreationSource {
    ///         static let scanner: Self =
    ///             DocumentCreationSource(id: "document-from-scanner")
    ///
    ///         static let template: Self =
    ///             DocumentCreationSource(id: "document-from-template")
    ///     }
    ///
    ///     DocumentGroupLaunchScene("Documents") {
    ///         NewDocumentButton("Scan Document", source: .scanner)
    ///         NewDocumentButton("New from Template", source: .template)
    ///     }
    ///
    /// When a document is created, you can retrieve its source from
    /// ``URLDocumentConfiguration`` or ``FileDocumentConfiguration``.
    ///
    /// - Parameter id: A string that uniquely identifies the creation flow
    ///   within your app.
    @available(macOS, unavailable)
    public init(id: String)

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: DocumentCreationSource, b: DocumentCreationSource) -> 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 DocumentGroup where Document : Observable, Document : ReadableDocument, Document.Reader.Source == URL {

    /// Creates a document group capable of opening and viewing read-only
    /// documents.
    ///
    /// - Parameters:
    ///   - viewer: The viewing UI for the provided document.
    ///   - makeDocument: A closure that creates the document
    ///     instance. Throw ``CancellationError`` to indicate that document
    ///     opening was cancelled.
    nonisolated public init(@ContentBuilder viewer: @escaping (_ document: Document) -> Content, makeReadableDocument: @escaping (_ configuration: URLDocumentConfiguration, _ context: DocumentCreationContext) async throws -> Document)
}

extension DocumentGroup where Document : Observable, Document : ReadableDocument, Document : WritableDocument, Document.Reader.Source == URL, Document.Writer.Destination == URL {

    /// Creates a document group capable of creating, viewing, and editing
    /// documents.
    ///
    /// - Parameters:
    ///   - allowCreating: Whether the document group supports creating
    ///     new documents in addition to opening and editing existing ones.
    ///   - editor: The editing UI for the provided document.
    ///   - makeDocument: A closure that creates the document instance.
    ///     Throw ``CancellationError`` to indicate that document creation
    ///     was cancelled.
    nonisolated public init(allowCreating: Bool = true, @ContentBuilder editor: @escaping (_ document: Document) -> Content, makeDocument: @escaping (_ configuration: URLDocumentConfiguration, _ context: DocumentCreationContext) async throws -> Document)
}

public struct DocumentReadConfiguration {

    /// The format of the file to read.
    public var contentType: UTType { get }
}

extension DocumentReadConfiguration : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

extension DocumentReadConfiguration : Equatable {

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

extension DocumentReadConfiguration : Hashable {

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

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

public protocol DocumentReader<Snapshot> {

    /// A type that represents the document's stored content.
    associatedtype Snapshot

    associatedtype Source

    /// Reads the document from disk.
    ///
    /// - Parameters:
    ///   - source: The source to read from.
    ///   - progress: The subprogress to report reading progress to
    ///     SwiftUI.
    nonisolated func read(from source: sending Self.Source, progress: consuming Subprogress) async throws -> sending Self.Snapshot
}

public struct DocumentWriteConfiguration {

    /// The format of the file to write.
    public var contentType: UTType { get }
}

extension DocumentWriteConfiguration : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    public var description: String { get }
}

public protocol DocumentWriter<Snapshot> {

    /// A type that represents the document's stored content.
    associatedtype Snapshot

    associatedtype Destination

    /// Writes the document content to disk.
    ///
    /// - Parameters:
    ///   - content: The content to write to disk.
    ///   - destination: The destination to write to.
    ///   - previous: The previously written content. Use it to skip
    ///     writing unchanged data.
    ///   - progress: The subprogress to report writing progress to
    ///     SwiftUI.
    nonisolated func write(content: sending Self.Snapshot, to destination: sending Self.Destination, previous: sending Self.Snapshot?, progress: consuming Subprogress) async throws
}

extension DragGesture {

    /// Creates a dragging gesture with the minimum dragging distance before the
    /// gesture succeeds, the coordinate space of the gesture's location, and
    /// the input kinds the gesture recognizes.
    ///
    /// - Parameters:
    ///   - minimumDistance: The minimum distance a person needs to drag
    ///     before the drag gesture begins.
    ///   - coordinateSpace: The coordinate space of the dragging gesture's
    ///     location.
    ///   - inputKinds: A set of input kinds that this gesture recognizes.
    ///     If not specified, the gesture will recognize all applicable input
    ///     kinds that a person can use to perform it.
    @MainActor @preconcurrency public init(minimumDistance: CGFloat = 10, coordinateSpace: some CoordinateSpaceProtocol = .local, inputKinds: GestureInputKinds = .all)
}

extension EmptyView : ToolbarContent {
}

extension EmptyView : CustomizableToolbarContent {
}

extension EmptyView : Commands {
}

extension EmptyView : SceneAccessoryContent {
}

nonisolated public struct ExternalNonInteractiveAccessory<Content> : SceneAccessoryContent where Content : View {

    /// Creates a scene accessory that presents non-interactive content on an
    /// external display.
    ///
    /// - Parameters:
    ///   - content: The scene's content.
    nonisolated public init(@ContentBuilder content: @escaping () -> Content)

    /// Creates a scene accessory that presents non-interactive content on an
    /// external display with a binding for programmatic enablement.
    ///
    /// - Parameters:
    ///   - isEnabled: A binding for whether or not the accessory should present
    ///     if available.
    ///   - content: The scene's content.
    nonisolated public init(isEnabled: Binding<Bool>, @ContentBuilder content: @escaping () -> Content)

    /// The composition of content that comprise the accessory content.
    nonisolated public var body: some SceneAccessoryContent { get }

    /// The type of content representing the body of this scene accessory
    /// content.
    @available(iOS 27.0, *)
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    @available(macCatalyst, unavailable)
    @available(visionOS, unavailable)
    public typealias Body = some SceneAccessoryContent
}

extension FileDocumentConfiguration {

    /// The source associated with the button that created this document.
    ///
    /// On iOS, you can specify the source via a ``NewDocumentButton`` in
    /// ``DocumentGroupLaunchScene``:
    ///
    ///     extension DocumentCreationSource {
    ///         static let scanner: Self =
    ///             DocumentCreationSource(id: "document-from-scanner")
    ///
    ///         static let template: Self =
    ///             DocumentCreationSource(id: "document-from-template")
    ///     }
    ///
    ///     DocumentGroupLaunchScene("Documents") {
    ///         NewDocumentButton("Scan Document", source: .scanner)
    ///         NewDocumentButton("New from Template", source: .template)
    ///     }
    ///
    /// Use this property to determine which ``NewDocumentButton`` triggered
    /// the creation of the current document, allowing you to customize the UI
    /// accordingly.
    public var creationSource: DocumentCreationSource? { get }
}

public struct FileWrapperDocumentReader<Snapshot> : DocumentReader {

    public typealias ReadConfiguration = DocumentReadConfiguration

    public typealias Source = URL

    /// Creates a reader that uses `FileWrapper` to read documents from disk.
    ///
    /// - Parameters:
    ///   - configuration: Properties required to read a document from disk.
    ///   - makeSnapshot: Deserializes a `FileWrapper` into a `Snapshot`.
    ///     Throw an error if the data is malformed.
    public init(_ configuration: sending FileWrapperDocumentReader<Snapshot>.ReadConfiguration, makeSnapshot: @escaping (FileWrapper) async throws -> sending Snapshot)

    /// Reads the document from disk.
    ///
    /// - Parameters:
    ///   - source: The source to read from.
    ///   - progress: The subprogress to report reading progress to
    ///     SwiftUI.
    nonisolated public func read(from source: sending URL, progress: consuming Subprogress) async throws -> sending Snapshot
}

public struct FileWrapperDocumentWriter<Snapshot> : DocumentWriter {

    public typealias WriteConfiguration = DocumentWriteConfiguration

    public typealias Destination = URL

    /// Creates a writer that uses `FileWrapper` to write documents to disk.
    ///
    /// - Parameters:
    ///   - configuration: Properties required to write a document to disk.
    ///   - makeFileWrapper: Serializes a `Snapshot` into a `FileWrapper`.
    public init(_ configuration: sending FileWrapperDocumentWriter<Snapshot>.WriteConfiguration, makeFileWrapper: @escaping (Snapshot) async throws -> FileWrapper)

    /// Writes the document content to disk.
    ///
    /// - Parameters:
    ///   - content: The content to write to disk.
    ///   - destination: The destination to write to.
    ///   - previous: The previously written content. Use it to skip
    ///     writing unchanged data.
    ///   - progress: The subprogress to report writing progress to
    ///     SwiftUI.
    nonisolated public func write(content: sending Snapshot, to destination: sending URL, previous: sending Snapshot?, progress: consuming Subprogress) async throws
}

extension Group : SceneAccessoryContent where Content : SceneAccessoryContent {
}

extension LongPressGesture {

    /// Creates a long-press gesture with a minimum duration, a maximum
    /// distance, and the input kinds the gesture recognizes.
    ///
    /// - Parameters:
    ///   - minimumDuration: The minimum duration of the long press that
    ///     must elapse before the gesture succeeds.
    ///   - maximumDistance: The maximum distance that the fingers or
    ///     cursor performing the long press can move before the gesture
    ///     fails.
    ///   - inputKinds: A set of input kinds that this gesture recognizes. If
    ///     not specified, the gesture will recognize all applicable input kinds
    ///     that a person can use to perform it.
    nonisolated public init(minimumDuration: Double = 0.5, maximumDistance: CGFloat = 10, inputKinds: GestureInputKinds = .all)
}

extension MagnifyGesture {

    /// Creates a magnify gesture with a given minimum delta for the gesture
    /// to start, and the input kinds the gesture recognizes.
    ///
    /// - Parameters:
    ///   - minimumScaleDelta: The minimum scale delta required before the
    ///     gesture starts.
    ///   - inputKinds: A set of input kinds that this gesture recognizes.
    ///     If not specified, the gesture will recognize all applicable input
    ///     kinds that a person can use to perform it.
    nonisolated public init(minimumScaleDelta: CGFloat = 0.01, inputKinds: GestureInputKinds = .all)
}

extension NavigationTransition where Self == CrossFadeNavigationTransition {

    /// A navigation transition that cross-fades between the appearing
    /// view and the disappearing view.
    ///
    /// Specify this transition in a sheet to have it appear by fading
    /// in over the content, as opposed to moving upwards to cover
    /// content.
    ///
    /// This example shows a sheet that appears with a cross-fade.
    ///
    ///     struct ContentView: View {
    ///         @State private var showSheet = false
    ///
    ///         var body: some View {
    ///             VStack {
    ///                 Button("Show Sheet") {
    ///                     showSheet = true
    ///                 }
    ///                 .sheet(isPresented: $showSheet) {
    ///                     Text("Sheet Content")
    ///                         .presentationDetents([.medium])
    ///                         .navigationTransition(.crossFade)
    ///                 }
    ///             }
    ///         }
    ///     }
    ///
    public static var crossFade: CrossFadeNavigationTransition { get }
}

extension Never : SceneAccessoryContent {
}

extension NewDocumentButton where Label == Text {

    /// Creates and opens new documents, tagging them with a creation source.
    ///
    ///     extension DocumentCreationSource {
    ///         static let brainstorming: Self =
    ///             DocumentCreationSource(id: "brainstorming")
    ///     }
    ///
    ///     DocumentGroupLaunchScene("Meeting Minutes") {
    ///         NewDocumentButton(Text("New meeting minutes…"))
    ///         NewDocumentButton(
    ///             Text("New brainstorming meeting…"),
    ///             source: .brainstorming
    ///         )
    ///     }
    ///
    /// - Parameters:
    ///   - label: A label for the button.
    ///   - contentType: An optional content type of the document to create.
    ///     If not provided, the first content type of the first document type
    ///     listed in the app definition is used.
    ///   - source: A source for the document creation flow. When a document is
    ///     created, you can retrieve its source from ``FileDocumentConfiguration``
    ///     or ``URLDocumentConfiguration``.
    nonisolated public init(_ label: Text? = nil, contentType: UTType? = nil, source: DocumentCreationSource)

    /// Creates and opens new documents, tagging them with a creation source.
    ///
    /// - Parameters:
    ///   - title: A title key to use as the button title.
    ///   - contentType: An optional content type of the document to create.
    ///   - source: A source for the document creation flow. When a document is
    ///     created, you can retrieve its source from ``FileDocumentConfiguration``
    ///     or ``URLDocumentConfiguration``.
    nonisolated public init(_ title: LocalizedStringKey, contentType: UTType? = nil, source: DocumentCreationSource)

    /// Creates and opens new documents, tagging them with a creation source.
    ///
    /// - Parameters:
    ///   - title: A title string to use as the button title.
    ///   - contentType: An optional content type of the document to create.
    ///   - source: A source for the document creation flow. When a document is
    ///     created, you can retrieve its source from ``FileDocumentConfiguration``
    ///     or ``URLDocumentConfiguration``.
    nonisolated public init(_ title: some StringProtocol, contentType: UTType? = nil, source: DocumentCreationSource)

    /// Creates and opens new documents, tagging them with a creation source.
    ///
    /// - Parameters:
    ///   - title: A localized string resource to use as the button title.
    ///   - contentType: An optional content type of the document to create.
    ///   - source: A source for the document creation flow. When a document is
    ///     created, you can retrieve its source from ``FileDocumentConfiguration``
    ///     or ``URLDocumentConfiguration``.
    nonisolated public init(_ title: LocalizedStringResource, contentType: UTType? = nil, source: DocumentCreationSource)

    /// Creates and opens new documents from a template picker.
    ///
    ///     NewDocumentButton(
    ///         Text("New from template"),
    ///         for: TextDocument.self,
    ///         source: .template
    ///     ) {
    ///         try await withCheckedThrowingContinuation { continuation in
    ///             documentCreationContinuation = continuation
    ///             showTemplatePicker = true
    ///         }
    ///     }
    ///
    /// - Parameters:
    ///   - label: A label for the button.
    ///   - documentType: The type of document to create.
    ///   - contentType: An optional content type of the document to create.
    ///   - source: A source for the document creation flow. When a document is
    ///     created, you can retrieve its source from ``FileDocumentConfiguration``
    ///     or ``URLDocumentConfiguration``.
    ///   - prepareDocument: Called when the user taps the button. Present a
    ///     template picker or other UI, then return the prepared document,
    ///     `nil` to request an empty document, or throw on cancellation.

Truncated.

extension NewDocumentButton where Label == DefaultNewDocumentButtonLabel {

    /// Creates and opens new documents from a specified source.
    ///
    /// The button creates new documents of the writable content types
    /// of all the document types supported by `DocumentGroup`s in
    /// the App definition. If a document type is not associated with
    /// any `DocumentGroup`, the button won't create new documents
    /// of that type.
    ///
    /// The framework watches for the relevant content types on the
    /// pasteboard. When there are no matching or conforming types,
    /// the button is disabled.
    ///
    /// - Parameter source: A source of data that fills the newly
    ///   created document.
    nonisolated public init(source: NewDocumentButtonDataSource)

    /// Creates a button that creates new documents using data from
    /// pasteboard.
    ///
    ///     struct NewTextDocumentFromPasteboardButton: View {
    ///         var body: some View {
    ///             NewDocumentButton(
    ///                 for: TextDocument.self, source: .pasteboard
    ///             )
    ///         }
    ///     }
    ///
    ///     struct TextDocument: FileDocument { ... }
    ///
    /// - Parameters:
    ///   - type: Type of documents to create from pasteboard data.
    ///   - source: A source of data that fills the newly created
    ///     document.
    nonisolated public init<D>(for type: D.Type, source: NewDocumentButtonDataSource) where D : FileDocument

    /// Creates a button that creates new documents using data from
    /// pasteboard.
    ///
    ///     struct NewTextDocumentFromPasteboardButton: View {
    ///         var body: some View {
    ///             NewDocumentButton(
    ///                 for: TextDocument.self, source: .pasteboard
    ///             )
    ///         }
    ///     }
    ///
    ///     class TextDocument: ReferenceFileDocument { ... }
    ///
    /// - Parameters:
    ///   - type: Type of documents to create from pasteboard data.
    ///   - source: A source of data that fills the newly created
    ///     document.
    nonisolated public init<D>(for type: D.Type, source: NewDocumentButtonDataSource) where D : ReferenceFileDocument
}

public struct NewDocumentButtonDataSource : Sendable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (lhs: NewDocumentButtonDataSource, rhs: NewDocumentButtonDataSource) -> 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 Optional : AccessibilityRotorContent where Wrapped : AccessibilityRotorContent {

    /// The type for the internal content of this `AccessibilityRotorContent`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Body = Never
}

extension Optional : SceneAccessoryContent where Wrapped : SceneAccessoryContent {

    /// The type of content representing the body of this scene accessory
    /// content.
    @available(iOS 27.0, *)
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    @available(macCatalyst, unavailable)
    @available(visionOS, unavailable)
    public typealias Body = Never
}

extension PickerStyle where Self == TabsPickerStyle {

    /// A picker style that presents options as segmented tabs.
    ///
    /// On macOS, this style produces a segmented picker with a visual treatment
    /// that distinguishes tab navigation from value selection. On iOS, tvOS,
    /// and visionOS, the visual appearance matches that of the standard
    /// standard `.segmented` style. On all supported platforms, VoiceOver announces
    /// options as tabs.
    ///
    /// ```swift
    /// Picker("View", selection: $view) {
    ///     Text("Events").tag(Views.events)
    ///     Text("Reminders").tag(Views.reminders)
    /// }
    /// .pickerStyle(.tabs)
    /// ```
    ///
    /// To apply this style to a picker, or to a view that contains pickers,
    /// use the ``View/pickerStyle(_:)`` modifier.
    public static var tabs: TabsPickerStyle { get }
}

public protocol ReadableDocument : AnyObject {

    /// A type that implements reading from disk logic.
    associatedtype Reader : DocumentReader

    /// The configuration for reading document contents.
    typealias ReadConfiguration = DocumentReadConfiguration

    /// The file and data types that the document reads from.
    static var readableContentTypes: [UTType] { get }

    /// Creates a value that reads a document from disk.
    ///
    /// - Parameters:
    ///   - configuration: Additional context for reading.
    func reader(configuration: sending Self.ReadConfiguration) -> sending Self.Reader

    /// Applies loaded content to the document model.
    ///
    /// SwiftUI calls this method on the main actor after reading completes.
    ///
    /// - Parameters:
    ///   - snapshot: The snapshot loaded from disk.
    ///   - previous: The previously loaded snapshot. Compare to `snapshot`
    ///     to update only what changed.
    @MainActor func apply(snapshot: sending Self.Reader.Snapshot, previous: sending Self.Reader.Snapshot?) async throws
}

extension ReadableDocument where Self : WritableDocument {

    /// By default, a document that supports reading also supports writing
    /// the same content types.
    public static var writableContentTypes: [UTType] { get }
}

public struct ReorderableSingleCollectionIdentifier : 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: ReorderableSingleCollectionIdentifier, b: ReorderableSingleCollectionIdentifier) -> Bool

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

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

public struct ReorderDifference<ItemID, CollectionID> {

    /// The destination value of a reordering operation.
    public struct Destination {

        /// The position within the destination collection.
        @frozen public enum Position {

            /// The position of the item with the associated identifier in its
            /// collection. Source items should be moved to the index of this
            /// item.
            case before(ItemID)

            /// The end of the collection. Source items should be appended to
            /// the end of the collection.
            case end
        }

        /// The collection that contains the destination's position.
        public var collectionID: CollectionID

        /// The identifier position in the collection where the sources should
        /// be moved to.
        public var position: ReorderDifference<ItemID, CollectionID>.Destination.Position

        /// Initializes the destination value with the provided position and
        /// collectionID.
        ///
        /// - Parameters:
        ///  - position: The position within the collection.
        ///  - destination: The identifier that represents this collection.
        public init(position: ReorderDifference<ItemID, CollectionID>.Destination.Position, collectionID: CollectionID)

        /// Initializes the destination value with the provided position and
        /// an instance of `ReorderableSingleCollectionIdentifier`.
        ///
        /// - Parameters:
        ///  - position: The position within the collection.
        public init(position: ReorderDifference<ItemID, CollectionID>.Destination.Position) where CollectionID == ReorderableSingleCollectionIdentifier
    }

    /// The identifiers of items moved during a reordering operation.
    public var sources: [ItemID]

    /// The end position of items moved during a reordering operation.
    public var destination: ReorderDifference<ItemID, CollectionID>.Destination
}

extension ReorderDifference : Equatable where ItemID : Equatable, CollectionID : Equatable {

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

extension ReorderDifference : Hashable where ItemID : Hashable, CollectionID : Hashable {

    /// 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 ReorderDifference : Sendable where ItemID : Sendable, CollectionID : Sendable {
}

extension ReorderDifference.Destination : Equatable where ItemID : Equatable, CollectionID : Equatable {

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

extension ReorderDifference.Destination : Hashable where ItemID : Hashable, CollectionID : Hashable {

    /// 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 ReorderDifference.Destination : Sendable where ItemID : Sendable, CollectionID : Sendable {
}

extension ReorderDifference.Destination.Position : Equatable where ItemID : Equatable {

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

extension ReorderDifference.Destination.Position : Hashable where ItemID : Hashable {

    /// 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 ReorderDifference.Destination.Position : Sendable where ItemID : Sendable {
}

extension RotateGesture {

    /// Creates a rotation gesture with a minimum delta for the gesture to
    /// start, and the input kinds the gesture recognizes.
    ///
    /// - Parameters:
    ///   - minimumAngleDelta: The minimum delta required before the gesture
    ///     starts. The default value is a one-degree angle.
    ///   - inputKinds: A set of input kinds that this gesture recognizes.
    ///     If not specified, the gesture will recognize all applicable input
    ///     kinds that a person can use to perform it.
    nonisolated public init(minimumAngleDelta: Angle = .degrees(1), inputKinds: GestureInputKinds = .all)
}

extension RotateGesture3D {

    /// Creates a rotation gesture with a minimum delta for the gesture to
    /// start, an axis to constrain measurement of rotation, and the input
    /// kinds the gesture should recognize.
    ///
    /// If the constrained axis is `nil`, the gesture measures unconstrained
    /// 3D rotation.
    ///
    /// - Parameters:
    ///   - constrainedToAxis: The 3D axis about which rotation is measured.
    ///   - minimumAngleDelta: The minimum delta required before the gesture
    ///     starts. The default value is a one-degree angle.
    ///   - inputKinds: A set of input kinds that this gesture recognizes.
    ///     If not specified, the gesture will recognize all applicable input
    ///     kinds that a person can use to perform it.
    nonisolated public init(constrainedToAxis: RotationAxis3D? = nil, minimumAngleDelta: Angle = .degrees(1), inputKinds: GestureInputKinds = .all)
}

@MainActor public protocol SceneAccessoryContent {

    /// The type of content representing the body of this scene accessory
    /// content.
    associatedtype Body : SceneAccessoryContent

    /// The composition of content that comprise the accessory content.
    @ContentBuilder @MainActor var body: Self.Body { get }
}

extension SceneAccessoryContent {

    /// Defines a callback for observing the availability of `self`.
    ///
    /// When the availability of a scene accessory changes,
    /// the specified closure will be called.
    ///
    /// For example, you can include additional controls based on
    /// the availability:
    ///
    ///     struct RootView: View {
    ///         @State private var isEnabled = false
    ///         @State private var isAvailable = false
    ///         var document: PresentationDocument
    ///
    ///         var body: some View {
    ///             PresentationDocumentView(document: document)
    ///                 .toolbar {
    ///                     if isAvailable {
    ///                         // Include a toolbar button to enable the
    ///                         // scene accessory when a display is available.
    ///                         SecondaryDisplayToggle(isEnabled: $isEnabled)
    ///                     }
    ///                 }
    ///                 .sceneAccessory {
    ///                     ExternalNonInteractiveAccessory(
    ///                         isEnabled: $isEnabled
    ///                     ) {
    ///                         PresentationPreview(document: document)
    ///                     }
    ///                     .onAvailabilityChange { newValue in
    ///                         isAvailable = newValue
    ///                     }
    ///                 }
    ///         }
    ///     }
    nonisolated public func onAvailabilityChange(perform action: @escaping (_ isAvailable: Bool) -> Void) -> some SceneAccessoryContent

}

extension SpatialTapGesture {

    /// Creates a tap gesture with the number of required taps, the coordinate
    /// space of the gesture's location, and the input kinds the gesture
    /// recognizes.
    ///
    /// - Parameters:
    ///   - count: The required number of taps to complete the tap gesture.
    ///   - coordinateSpace: The coordinate space of the tap gesture's
    ///     location.
    ///   - inputKinds: A set of input kinds that this gesture recognizes.
    ///     If not specified, the gesture will recognize all applicable input
    ///     kinds that a person can use to perform it.
    nonisolated public init(count: Int = 1, coordinateSpace: some CoordinateSpaceProtocol = .local, inputKinds: GestureInputKinds = .all)
}

extension TabContent {

    /// Adds help text to a tab using a localized string that you provide.
    ///
    /// Adding help to a tab configures the tab's accessibility hint and
    /// its help tag (also called a _tooltip_) in macOS or visionOS.
    /// For more information on using help tags, see
    /// <doc://com.apple.documentation/design/human-interface-guidelines/offering-help>
    /// in the Human Interface Guidelines.
    ///
    ///     TabView {
    ///         Tab("List", systemImage: "list.dash") {
    ///             ListView()
    ///         }
    ///         .help("Display symbols in list format")
    ///     }
    ///
    /// - Parameter textKey: The key for the localized text to use as help.
    nonisolated public func help(_ textKey: LocalizedStringKey) -> some TabContent<Self.TabValue>


    /// Adds help text to a tab using a localized string resource that you
    /// provide.
    ///
    /// Adding help to a tab configures the tab's accessibility hint and
    /// its help tag (also called a _tooltip_) in macOS or visionOS.
    /// For more information on using help tags, see
    /// <doc://com.apple.documentation/design/human-interface-guidelines/offering-help>
    /// in the Human Interface Guidelines.
    ///
    ///     TabView {
    ///         Tab("List", systemImage: "list.dash") {
    ///             ListView()
    ///         }
    ///         .help("Display symbols in list format")
    ///     }
    ///
    /// - Parameter textResource: Text resource for the localized text to use as help.
    nonisolated public func help(_ textResource: LocalizedStringResource) -> some TabContent<Self.TabValue>


    /// Adds help text to a tab using a string that you provide.
    ///
    /// Adding help to a tab configures the tab's accessibility hint and
    /// its help tag (also called a _tooltip_) in macOS or visionOS.
    /// For more information on using help tags, see
    /// <doc://com.apple.documentation/design/human-interface-guidelines/offering-help>
    /// in the Human Interface Guidelines.
    ///
    ///     TabView {
    ///         Tab("List", systemImage: "list.dash") {
    ///             ListView()
    ///         }
    ///         .help("Display symbols in list format")
    ///     }
    ///
    /// - Parameter text: The text to use as help.
    nonisolated public func help<S>(_ text: S) -> some TabContent<Self.TabValue> where S : StringProtocol


    /// Adds help text to a tab using a text view that you provide.
    ///
    /// Adding help to a tab configures the tab's accessibility hint and
    /// its help tag (also called a _tooltip_) in macOS or visionOS.
    /// For more information on using help tags, see
    /// <doc://com.apple.documentation/design/human-interface-guidelines/offering-help>
    /// in the Human Interface Guidelines.
    ///
    ///     TabView {
    ///         Tab("List", systemImage: "list.dash") {
    ///             ListView()
    ///         }
    ///         .help(Text("Display symbols in list format"))
    ///     }
    ///
    /// - Parameter text: The ``Text`` view to use as help.
    nonisolated public func help(_ text: Text) -> some TabContent<Self.TabValue>

}

public struct TabSectionExpansion : Sendable, Hashable {

    /// The system determines the default expansion state.
    public static let automatic: TabSectionExpansion

    /// The section is initially expanded in the sidebar.
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    public static let expanded: TabSectionExpansion

    /// The section is initially collapsed in the sidebar.
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    public static let collapsed: TabSectionExpansion

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

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

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

public struct TabsPickerStyle : PickerStyle {

    /// Creates a tabs picker style.
    public init()
}

extension ToolbarContent {

    /// Defines the visibility priority for a toolbar item.
    ///
    /// When toolbar space is limited, items with a lower priority
    /// move into the overflow menu before items with a higher priority.
    /// The default is ``ToolbarItemVisibilityPriority/automatic``.
    ///
    /// For example, an important control can appear at the trailing edge
    /// of the toolbar, but still be shown as the window is made smaller:
    ///
    ///     struct RootView: View {
    ///         var body: some View {
    ///             ContentView()
    ///                 .toolbar {
    ///                     ToolbarItem {
    ///                         SecondaryControl()
    ///                     }
    ///                     ToolbarItem {
    ///                         PrimaryControl()
    ///                     }
    ///                     .visibilityPriority(.high)
    ///                 }
    ///         }
    ///     }
    ///
    /// - Parameter priority: The visibility priority for this toolbar
    ///   item.
    @MainActor @preconcurrency public func visibilityPriority(_ priority: ToolbarItemVisibilityPriority) -> some ToolbarContent

}

public struct ToolbarItemVisibilityPriority : Hashable, Sendable {

    /// The default priority that lets the system determine the item's
    /// visibility in the toolbar.
    public static let automatic: ToolbarItemVisibilityPriority

    /// A priority that moves the item to the overflow menu before
    /// items with the default or high priority.
    ///
    /// Use for secondary actions, such as archive or delete, that
    /// don't need persistent visibility in the toolbar.
    @available(iOS 27.0, macOS 26.1, *)
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    @available(visionOS, unavailable)
    public static let low: ToolbarItemVisibilityPriority

    /// A priority that keeps the item in the toolbar longer than
    /// items with the default or low priority.
    ///
    /// Use for frequently used actions that need to stay visible as
    /// the toolbar shrinks.
    @available(iOS 27.0, macOS 26.1, *)
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    @available(visionOS, unavailable)
    public static let high: ToolbarItemVisibilityPriority

    /// Creates a priority lower than the specified value.
    ///
    /// The priority is lower than `other` but doesn't cross below
    /// the next lower system priority. For example,
    /// `ToolbarItemVisibilityPriority(lowerThan: .high)` returns a value
    /// that is less than `.high` but greater than `.automatic`.
    ///
    /// Priorities created with the same base value are equal:
    ///
    ///     let x = ToolbarItemVisibilityPriority(lowerThan: .high)
    ///     let y = ToolbarItemVisibilityPriority(lowerThan: .high)
    ///     x == y // true
    ///
    @available(iOS 27.0, macOS 27.0, *)
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    @available(visionOS, unavailable)
    public init(lowerThan other: ToolbarItemVisibilityPriority)

    /// Creates a priority higher than the specified value.
    ///
    /// The priority is higher than `other` but doesn't cross above
    /// the next higher system priority. For example,
    /// `ToolbarItemVisibilityPriority(higherThan: .high)` returns a
    /// value that is greater than `.high`.
    ///
    /// Priorities created with the same base value are equal:
    ///
    ///     let x = ToolbarItemVisibilityPriority(higherThan: .high)
    ///     let y = ToolbarItemVisibilityPriority(higherThan: .high)
    ///     x == y // true
    ///
    @available(iOS 27.0, macOS 27.0, *)
    @available(watchOS, unavailable)
    @available(tvOS, unavailable)
    @available(visionOS, unavailable)
    public init(higherThan other: ToolbarItemVisibilityPriority)

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

Truncated.

extension ToolbarItemVisibilityPriority : Comparable {

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is less than that of the second argument.
    ///
    /// This function is the only requirement of the `Comparable` protocol. The
    /// remainder of the relational operator functions are implemented by the
    /// standard library for any type that conforms to `Comparable`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func < (lhs: ToolbarItemVisibilityPriority, rhs: ToolbarItemVisibilityPriority) -> Bool
}

public struct ToolbarMinimizationSafeAreaAdjustment : Hashable, Sendable {

    /// The system determines the safe area adjustment.
    public static let automatic: ToolbarMinimizationSafeAreaAdjustment

    /// The safe area adjusts interactively as bars minimize.
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    @available(visionOS, unavailable)
    public static let enabled: ToolbarMinimizationSafeAreaAdjustment

    /// The safe area remains unchanged as bars minimize.
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    @available(visionOS, unavailable)
    public static let disabled: ToolbarMinimizationSafeAreaAdjustment

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

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

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

public struct ToolbarMinimizeBehavior : Hashable, Sendable {

    /// The system determines the minimize behavior. By default,
    /// navigation bars on iOS will minimize when the view has a
    /// searchable using the ``SearchFieldPlacement/toolbarPrincipal``
    /// placement.
    public static var automatic: ToolbarMinimizeBehavior { get }

    /// Minimize when scrolling down.
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    @available(visionOS, unavailable)
    public static let onScrollDown: ToolbarMinimizeBehavior

    /// Minimize when scrolling up.
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    @available(visionOS, unavailable)
    public static let onScrollUp: ToolbarMinimizeBehavior

    /// The toolbar cannot be minimized.
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    @available(visionOS, unavailable)
    public static let never: ToolbarMinimizeBehavior

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

nonisolated public struct ToolbarOverflowMenu<Content> : ToolbarContent, CustomizableToolbarContent, ~Sendable where Content : View {

    /// Creates toolbar overflow menu content.
    ///
    /// - Parameter content: The content of the overflow menu.
    nonisolated public init(@ContentBuilder content: () -> Content)

    /// The type of content representing the body of this toolbar content.
    @available(iOS 27.0, *)
    @available(macOS, unavailable)
    @available(tvOS, unavailable)
    @available(watchOS, unavailable)
    public typealias Body = Never
}

extension TupleContent : ToolbarContent where repeat each Content : ToolbarContent {

    /// The type of content representing the body of this toolbar content.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Body = Never
}

extension TupleContent : CustomizableToolbarContent where repeat each Content : CustomizableToolbarContent {
}

extension TupleContent : AccessibilityRotorContent where repeat each Content : AccessibilityRotorContent {

    /// The type for the internal content of this `AccessibilityRotorContent`.
    @available(macOS 27.0, iOS 27.0, tvOS 27.0, watchOS 27.0, *)
    public typealias Body = Never
}

extension TupleContent : Commands where repeat each Content : Commands {

    /// The type of commands that represents the body of this command hierarchy.
    ///
    /// When you create custom commands, Swift infers this type from your
    /// implementation of the required ``SwiftUI/Commands/body-swift.property``
    /// property.
    @available(macOS 27.0, iOS 27.0, *)
    @available(tvOS, unavailable, introduced: 26.0)
    @available(watchOS, unavailable, introduced: 26.0)
    public typealias Body = Never
}

extension TupleContent : SceneAccessoryContent where repeat each Content : SceneAccessoryContent {

    /// The type of content representing the body of this scene accessory
    /// content.
    @available(iOS 27.0, *)
    @available(macOS, unavailable, introduced: 26.0)
    @available(tvOS, unavailable, introduced: 26.0)
    @available(watchOS, unavailable, introduced: 26.0)
    @available(macCatalyst, unavailable)
    @available(visionOS, unavailable)
    public typealias Body = Never
}

public protocol UIHostingSceneDelegate : UISceneDelegate {

    associatedtype RootScene : Scene

    @SceneBuilder static var rootScene: Self.RootScene { get }
}

extension URLDocumentConfiguration : Sendable {
}

extension URLDocumentConfiguration : CustomStringConvertible {

    /// A textual representation of this instance.
    ///
    /// Calling this property directly is discouraged. Instead, convert an
    /// instance of any type to a string by using the `String(describing:)`
    /// initializer. This initializer works with any type, and uses the custom
    /// `description` property for types that conform to
    /// `CustomStringConvertible`:
    ///
    ///     struct Point: CustomStringConvertible {
    ///         let x: Int, y: Int
    ///
    ///         var description: String {
    ///             return "(\(x), \(y))"
    ///         }
    ///     }
    ///
    ///     let p = Point(x: 21, y: 30)
    ///     let s = String(describing: p)
    ///     print(s)
    ///     // Prints "(21, 30)"
    ///
    /// The conversion of `p` to a string in the assignment to `s` uses the
    /// `Point` type's `description` property.
    @MainActor final public var description: String { get }
}

extension URLDocumentConfiguration : Equatable, Hashable {

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    @MainActor public static func == (lhs: URLDocumentConfiguration, rhs: URLDocumentConfiguration) -> 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.
    @MainActor final 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.
    nonisolated final public var hashValue: Int { get }
}

extension URLDocumentConfiguration {

    /// The source associated with the button that created this document.
    ///
    /// On iOS, you can specify the source via a ``NewDocumentButton`` in
    /// ``DocumentGroupLaunchScene``:
    ///
    ///     extension DocumentCreationSource {
    ///         static let scanner: Self =
    ///             DocumentCreationSource(id: "document-from-scanner")
    ///
    ///         static let template: Self =
    ///             DocumentCreationSource(id: "document-from-template")
    ///     }
    ///
    ///     DocumentGroupLaunchScene("Documents") {
    ///         NewDocumentButton("Scan Document", source: .scanner)
    ///         NewDocumentButton("New from Template", source: .template)
    ///     }
    ///
    /// Use this property to determine which ``NewDocumentButton`` triggered
    /// the creation of the current document, allowing you to customize the UI
    /// accordingly.
    @MainActor final public var creationSource: DocumentCreationSource? { get }
}

extension URLDocumentConfiguration : nonisolated Observable {
}

extension ViewBuilder {

    public static func buildLimitedAvailability(_ content: any SceneAccessoryContent) -> some SceneAccessoryContent

}

public protocol WritableDocument : AnyObject {

    /// A type that implements writing to disk logic.
    associatedtype Writer : DocumentWriter

    /// The configuration for writing document contents.
    typealias WriteConfiguration = DocumentWriteConfiguration

    /// The file types that the document supports saving or exporting to.
    static var writableContentTypes: [UTType] { get }

    /// Creates a value that writes a document to disk.
    ///
    /// - Parameters:
    ///   - configuration: Additional context for writing.
    func writer(configuration: sending Self.WriteConfiguration) -> sending Self.Writer

    /// Creates a snapshot of the document's current state to be saved.
    ///
    /// SwiftUI calls this on the main actor when saving. Perform expensive
    /// serialization inside
    /// ``DocumentWriter.write(content:to:previous:progress:)``
    /// rather than here.
    ///
    /// - Parameters:
    ///   - contentType: The format of the data requested.
    @MainActor func snapshot(contentType: UTType) async throws -> sending Self.Writer.Snapshot
}