From 9ea3d5e397ce37afa4a6a20d8756ed3abb940e70 Mon Sep 17 00:00:00 2001 From: Shaps Benkau Date: Sat, 6 Jun 2026 00:08:03 +0100 Subject: [PATCH 01/10] Automate generated backport API inventory Add a symbol-graph based generator that writes APIs.md with grouped backport-facing public API signatures and availability, update README to link to APIs.md, and add a PR workflow that regenerates and auto-commits APIs.md when needed. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .github/scripts/generate-public-api-list.sh | 29 ++ .../scripts/generate_public_api_list.swift | 478 ++++++++++++++++++ .github/workflows/public-api-sync.yml | 53 ++ APIs.md | 7 + README.md | 39 +- 5 files changed, 572 insertions(+), 34 deletions(-) create mode 100644 .github/scripts/generate-public-api-list.sh create mode 100644 .github/scripts/generate_public_api_list.swift create mode 100644 .github/workflows/public-api-sync.yml create mode 100644 APIs.md diff --git a/.github/scripts/generate-public-api-list.sh b/.github/scripts/generate-public-api-list.sh new file mode 100644 index 00000000..582067f7 --- /dev/null +++ b/.github/scripts/generate-public-api-list.sh @@ -0,0 +1,29 @@ +#!/usr/bin/env bash +set -euo pipefail + +mode="--write" +if [[ "${1:-}" == "--check" ]]; then + mode="--check" +fi + +repo_root="$(git rev-parse --show-toplevel)" +symbol_graph_dir="${repo_root}/.build/public-api-symbol-graphs" +apis_path="${repo_root}/APIs.md" + +rm -rf "${symbol_graph_dir}" +mkdir -p "${symbol_graph_dir}" + +if ! command -v swift >/dev/null 2>&1; then + echo "error: Swift is required to generate the public API list." >&2 + exit 1 +fi + +swift package dump-symbol-graph \ + --target SwiftUIBackports \ + --minimum-access-level public \ + --output-path "${symbol_graph_dir}" + +swift "${repo_root}/.github/scripts/generate_public_api_list.swift" \ + --symbol-graphs-dir "${symbol_graph_dir}" \ + --apis-file "${apis_path}" \ + "${mode}" diff --git a/.github/scripts/generate_public_api_list.swift b/.github/scripts/generate_public_api_list.swift new file mode 100644 index 00000000..7c4f2678 --- /dev/null +++ b/.github/scripts/generate_public_api_list.swift @@ -0,0 +1,478 @@ +import Foundation + +private let generatorNote = "This file is auto-generated by `.github/scripts/generate-public-api-list.sh`." + +private struct SymbolEntry { + let precise: String + let group: String + let title: String + let signature: String + var availabilityByDomain: [String: String] +} + +private enum Mode { + case write + case check +} + +private struct Configuration { + let symbolGraphsDirectory: URL + let apiFilePath: URL + let mode: Mode +} + +private func fail(_ message: String) -> Never { + fputs("error: \(message)\n", stderr) + exit(1) +} + +private func parseArguments() -> Configuration { + var arguments = Array(CommandLine.arguments.dropFirst()) + var symbolGraphsDirectory: URL? + var apiFilePath: URL? + var mode: Mode = .write + + while !arguments.isEmpty { + let argument = arguments.removeFirst() + switch argument { + case "--symbol-graphs-dir": + guard !arguments.isEmpty else { + fail("Missing value for --symbol-graphs-dir") + } + symbolGraphsDirectory = URL(fileURLWithPath: arguments.removeFirst()) + case "--apis-file": + guard !arguments.isEmpty else { + fail("Missing value for --apis-file") + } + apiFilePath = URL(fileURLWithPath: arguments.removeFirst()) + case "--check": + mode = .check + case "--write": + mode = .write + default: + fail("Unknown argument: \(argument)") + } + } + + guard let symbolGraphsDirectory else { + fail("Argument --symbol-graphs-dir is required") + } + + guard let apiFilePath else { + fail("Argument --apis-file is required") + } + + return Configuration( + symbolGraphsDirectory: symbolGraphsDirectory, + apiFilePath: apiFilePath, + mode: mode + ) +} + +private func fileURLs(in directory: URL) -> [URL] { + guard let enumerator = FileManager.default.enumerator( + at: directory, + includingPropertiesForKeys: nil, + options: [.skipsHiddenFiles] + ) else { + return [] + } + + return enumerator.compactMap { item in + guard let url = item as? URL else { return nil } + return url.pathExtension == "json" ? url : nil + } +} + +private func string(from declarationFragments: Any?) -> String? { + guard let fragments = declarationFragments as? [[String: Any]] else { + return nil + } + + let output = fragments.compactMap { fragment -> String? in + fragment["spelling"] as? String + }.joined() + + return output.isEmpty ? nil : output +} + +private func normalizedWhitespace(_ string: String) -> String { + string + .replacingOccurrences(of: "\\s+", with: " ", options: .regularExpression) + .trimmingCharacters(in: .whitespacesAndNewlines) +} + +private func normalizedSignature(_ signature: String) -> String { + var result = normalizedWhitespace(signature) + + while result.hasPrefix("public ") || result.hasPrefix("open ") { + if result.hasPrefix("public ") { + result.removeFirst("public ".count) + } else if result.hasPrefix("open ") { + result.removeFirst("open ".count) + } + result = normalizedWhitespace(result) + } + + return result +} + +private func fallbackSignature(kindIdentifier: String, title: String) -> String { + if kindIdentifier.contains("func") { + return "func \(title)" + } + if kindIdentifier.contains("property") || kindIdentifier.contains("var") { + return "var \(title)" + } + if kindIdentifier.contains("enum") { + return "enum \(title)" + } + if kindIdentifier.contains("struct") { + return "struct \(title)" + } + if kindIdentifier.contains("class") { + return "class \(title)" + } + if kindIdentifier.contains("protocol") { + return "protocol \(title)" + } + if kindIdentifier.contains("typealias") { + return "typealias \(title)" + } + if kindIdentifier.contains("init") { + return "init\(title)" + } + return title +} + +private func versionString(from introduced: [String: Any]) -> String? { + guard let major = introduced["major"] as? Int else { + return nil + } + let minor = introduced["minor"] as? Int ?? 0 + let patch = introduced["patch"] as? Int ?? 0 + + if patch > 0 { + return "\(major).\(minor).\(patch)" + } + if minor > 0 { + return "\(major).\(minor)" + } + return "\(major)" +} + +private func versionComponents(_ version: String) -> [Int] { + let components = version.split(separator: ".").map { Int($0) ?? 0 } + if components.count >= 3 { + return Array(components.prefix(3)) + } + if components.count == 2 { + return [components[0], components[1], 0] + } + if components.count == 1 { + return [components[0], 0, 0] + } + return [0, 0, 0] +} + +private func lowerVersion(_ lhs: String, _ rhs: String) -> String { + let left = versionComponents(lhs) + let right = versionComponents(rhs) + if left.lexicographicallyPrecedes(right) { + return lhs + } + return rhs +} + +private func availabilityByDomain(from availability: Any?) -> [String: String] { + guard let availabilityEntries = availability as? [[String: Any]] else { + return [:] + } + + var output: [String: String] = [:] + let supportedDomains = Set(["iOS", "tvOS", "watchOS", "macOS"]) + + for entry in availabilityEntries { + guard let domain = entry["domain"] as? String, supportedDomains.contains(domain) else { + continue + } + guard let introduced = entry["introduced"] as? [String: Any], let version = versionString(from: introduced) else { + continue + } + + if let existing = output[domain] { + output[domain] = lowerVersion(existing, version) + } else { + output[domain] = version + } + } + + return output +} + +private func isBackportFacing(pathComponents: [String], title: String) -> Bool { + if pathComponents.contains("Backport") { + return true + } + if pathComponents.contains("EnvironmentValues") { + return true + } + if title == "backport" || title.hasPrefix("backport") { + return true + } + if let last = pathComponents.last, last == "backport" || last.hasPrefix("backport") { + return true + } + return false +} + +private func groupName(pathComponents: [String], title: String, signature: String, kindIdentifier: String) -> String { + if pathComponents.contains("EnvironmentValues") || (title.hasPrefix("backport") && signature.contains("EnvironmentValues")) { + return "Environment Backports" + } + if title == "backport", pathComponents.contains("View") { + return "View Namespace" + } + if title == "backport", pathComponents.contains("AnyTransition") { + return "Transition Namespace" + } + if pathComponents.contains("Backport") { + if kindIdentifier.contains("func") + || kindIdentifier.contains("subscript") + || signature.hasPrefix("func ") + || signature.hasPrefix("subscript") + { + return "Modifiers" + } + return "Backport Namespace" + } + return "Other Backport API" +} + +private func loadSymbolEntries(from file: URL) -> [SymbolEntry] { + guard let data = try? Data(contentsOf: file) else { + fail("Unable to read symbol graph file at \(file.path)") + } + + guard let raw = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { + fail("Unable to decode JSON in \(file.path)") + } + + guard let symbols = raw["symbols"] as? [String: Any] else { + return [] + } + + var output: [SymbolEntry] = [] + + for (_, symbolValue) in symbols { + guard let symbol = symbolValue as? [String: Any] else { continue } + + guard let accessLevel = symbol["accessLevel"] as? String, + accessLevel == "public" || accessLevel == "open" + else { + continue + } + + guard let identifier = symbol["identifier"] as? [String: Any], + let precise = identifier["precise"] as? String + else { + continue + } + + let names = symbol["names"] as? [String: Any] + let title = (names?["title"] as? String)? + .trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + let pathComponents = symbol["pathComponents"] as? [String] ?? [] + + guard isBackportFacing(pathComponents: pathComponents, title: title) else { + continue + } + + let kind = symbol["kind"] as? [String: Any] + let kindIdentifier = kind?["identifier"] as? String ?? "" + + let declaration = string(from: symbol["declarationFragments"]) + ?? string(from: names?["subHeading"]) + ?? fallbackSignature(kindIdentifier: kindIdentifier, title: title) + + let signature = normalizedSignature(declaration) + guard !signature.isEmpty else { continue } + + let availability = availabilityByDomain(from: symbol["availability"]) + + output.append( + SymbolEntry( + precise: precise, + group: groupName( + pathComponents: pathComponents, + title: title, + signature: signature, + kindIdentifier: kindIdentifier + ), + title: title, + signature: signature, + availabilityByDomain: availability + ) + ) + } + + return output +} + +private func mergedEntries(_ entries: [SymbolEntry]) -> [SymbolEntry] { + var byPrecise: [String: SymbolEntry] = [:] + + for entry in entries { + if var existing = byPrecise[entry.precise] { + for (domain, version) in entry.availabilityByDomain { + if let current = existing.availabilityByDomain[domain] { + existing.availabilityByDomain[domain] = lowerVersion(current, version) + } else { + existing.availabilityByDomain[domain] = version + } + } + + if entry.signature.count > existing.signature.count { + byPrecise[entry.precise] = SymbolEntry( + precise: existing.precise, + group: existing.group, + title: existing.title, + signature: entry.signature, + availabilityByDomain: existing.availabilityByDomain + ) + } else { + byPrecise[entry.precise] = existing + } + } else { + byPrecise[entry.precise] = entry + } + } + + return Array(byPrecise.values) +} + +private func availabilityLine(for availabilityByDomain: [String: String]) -> String? { + let domainOrder = ["iOS", "tvOS", "watchOS", "macOS"] + let parts = domainOrder.compactMap { domain -> String? in + guard let version = availabilityByDomain[domain] else { return nil } + return "\(domain) \(version)" + } + + guard !parts.isEmpty else { + return nil + } + + return "@available(\(parts.joined(separator: ", ")), *)" +} + +private func generatedDocument(from entries: [SymbolEntry]) -> String { + let groupOrder = [ + "View Namespace", + "Transition Namespace", + "Environment Backports", + "Modifiers", + "Backport Namespace", + "Other Backport API" + ] + + let grouped = Dictionary(grouping: entries, by: { $0.group }) + let allGroups = Array(grouped.keys) + let sortedGroups = allGroups.sorted { lhs, rhs in + let left = groupOrder.firstIndex(of: lhs) ?? Int.max + let right = groupOrder.firstIndex(of: rhs) ?? Int.max + if left == right { return lhs < rhs } + return left < right + } + + var lines: [String] = [ + "# Available APIs", + "", + generatorNote, + "", + "## Public API", + "" + ] + + var hasAtLeastOneEntry = false + for group in sortedGroups { + guard let symbols = grouped[group], !symbols.isEmpty else { + continue + } + hasAtLeastOneEntry = true + + lines.append("### \(group)") + lines.append("") + + let orderedSymbols = symbols.sorted { + if $0.title == $1.title { + if $0.signature == $1.signature { + return $0.precise < $1.precise + } + return $0.signature < $1.signature + } + return $0.title < $1.title + } + + for symbol in orderedSymbols { + if let availability = availabilityLine(for: symbol.availabilityByDomain) { + lines.append("- `\(availability)` ") + lines.append(" `\(symbol.signature)`") + } else { + lines.append("- `\(symbol.signature)`") + } + } + + lines.append("") + } + + if !hasAtLeastOneEntry { + lines.append("_No API entries generated._") + } + + return lines.joined(separator: "\n") +} + +private func run() { + let configuration = parseArguments() + let symbolGraphFiles = fileURLs(in: configuration.symbolGraphsDirectory) + + if symbolGraphFiles.isEmpty { + fail("No symbol graph JSON files found at \(configuration.symbolGraphsDirectory.path)") + } + + let allEntries = symbolGraphFiles.flatMap(loadSymbolEntries(from:)) + let entries = mergedEntries(allEntries) + let generated = generatedDocument(from: entries) + + let existingAPIDocument: String + do { + existingAPIDocument = try String(contentsOf: configuration.apiFilePath, encoding: .utf8) + } catch { + existingAPIDocument = "" + } + + let changed = generated != existingAPIDocument + + switch configuration.mode { + case .write: + if changed { + do { + try generated.write(to: configuration.apiFilePath, atomically: true, encoding: .utf8) + print("Updated APIs.md public API list.") + } catch { + fail("Unable to write updated API file at \(configuration.apiFilePath.path)") + } + } else { + print("APIs.md public API list is already up to date.") + } + case .check: + if changed { + print("APIs.md public API list is out of date.") + exit(2) + } else { + print("APIs.md public API list is up to date.") + } + } +} + +run() diff --git a/.github/workflows/public-api-sync.yml b/.github/workflows/public-api-sync.yml new file mode 100644 index 00000000..7ab79564 --- /dev/null +++ b/.github/workflows/public-api-sync.yml @@ -0,0 +1,53 @@ +name: Public API Sync + +on: + pull_request: + types: [opened, reopened, synchronize, ready_for_review] + paths: + - "Sources/**" + - ".github/scripts/**" + - ".github/workflows/public-api-sync.yml" + - "APIs.md" + - "README.md" + +permissions: + contents: write + +jobs: + sync-public-api: + runs-on: macos-latest + + steps: + - name: Checkout PR branch + uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Regenerate public API list + shell: bash + run: bash .github/scripts/generate-public-api-list.sh --write + + - name: Detect API doc changes + id: apis_diff + shell: bash + run: | + if git diff --quiet -- APIs.md; then + echo "changed=false" >> "$GITHUB_OUTPUT" + else + echo "changed=true" >> "$GITHUB_OUTPUT" + fi + + - name: Auto-commit APIs update + if: steps.apis_diff.outputs.changed == 'true' && github.event.pull_request.head.repo.full_name == github.repository + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_message: "Update generated public API list in APIs.md" + file_pattern: APIs.md + + - name: Fail when APIs.md cannot be auto-updated + if: steps.apis_diff.outputs.changed == 'true' && github.event.pull_request.head.repo.full_name != github.repository + shell: bash + run: | + echo "::error::APIs.md public API list is out of date, but this PR branch is not writable by CI." + echo "::error::Run bash .github/scripts/generate-public-api-list.sh --write and push the result." + exit 1 diff --git a/APIs.md b/APIs.md new file mode 100644 index 00000000..734524da --- /dev/null +++ b/APIs.md @@ -0,0 +1,7 @@ +# Available APIs + +This file is auto-generated by `.github/scripts/generate-public-api-list.sh`. + +## Public API + +_No API entries generated._ diff --git a/README.md b/README.md index 75a74281..a75cefbf 100644 --- a/README.md +++ b/README.md @@ -61,40 +61,11 @@ Environment: @Environment(\.backportRefresh) private var refreshAction ``` -## Backports - -**SwiftUI** - -- `AsyncImage` -- `AppStorage` -- `background` – ViewBuilder API -- `DismissAction` -- `DynamicTypeSize` -– `Label` -– `LabeledContent` -- `NavigationDestination` – uses a standard NavigationView -- `navigationTitle` – newer API -- `overlay` – ViewBuilder API -- `onChange` -- `openURL` -- `ProgressView` -- `presentationDetents` -- `presentationDragIndicator` -- `quicklookPreview` -- `requestReview` -- `Refreshable` – includes pull-to-refresh  -- `ScaledMetric` -- `ShareLink` -- `StateObject` -- `scrollDisabled` -- `scrollDismissesKeyboard` -- `scrollIndicators` -- `Section(_ header:)` -- `task` – async/await modifier - -**UIKit** - -- `UIHostingConfiguration` – simplifies embedding SwiftUI in `UICollectionViewCell` and `UITableViewCell` +## Public API + +For the complete generated API inventory, see **[Available APIs](./APIs.md)**. + +Run `bash .github/scripts/generate-public-api-list.sh --write` whenever you add or modify public backport-facing API. ## Extras From 7060db7bc9d8e89cdec72917d40ad49fd1817fed Mon Sep 17 00:00:00 2001 From: Shaps Benkau Date: Sat, 6 Jun 2026 00:10:28 +0100 Subject: [PATCH 02/10] Support older dump-symbol-graph CLI Detect available dump-symbol-graph flags and fall back to stdout redirection when --output-path is unavailable. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .github/scripts/generate-public-api-list.sh | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/.github/scripts/generate-public-api-list.sh b/.github/scripts/generate-public-api-list.sh index 582067f7..6f3cd192 100644 --- a/.github/scripts/generate-public-api-list.sh +++ b/.github/scripts/generate-public-api-list.sh @@ -9,6 +9,7 @@ fi repo_root="$(git rev-parse --show-toplevel)" symbol_graph_dir="${repo_root}/.build/public-api-symbol-graphs" apis_path="${repo_root}/APIs.md" +cd "${repo_root}" rm -rf "${symbol_graph_dir}" mkdir -p "${symbol_graph_dir}" @@ -18,10 +19,20 @@ if ! command -v swift >/dev/null 2>&1; then exit 1 fi -swift package dump-symbol-graph \ - --target SwiftUIBackports \ - --minimum-access-level public \ - --output-path "${symbol_graph_dir}" +help_text="$(swift package dump-symbol-graph -help 2>&1 || true)" + +dump_command=(swift package dump-symbol-graph --minimum-access-level public) + +if grep -q -- "--target" <<< "${help_text}"; then + dump_command+=(--target SwiftUIBackports) +fi + +if grep -q -- "--output-path" <<< "${help_text}"; then + dump_command+=(--output-path "${symbol_graph_dir}") + "${dump_command[@]}" +else + "${dump_command[@]}" > "${symbol_graph_dir}/SwiftUIBackports.symbols.json" +fi swift "${repo_root}/.github/scripts/generate_public_api_list.swift" \ --symbol-graphs-dir "${symbol_graph_dir}" \ From 3ac454d7a73bc3c583bb4f10c2ff68f444a72783 Mon Sep 17 00:00:00 2001 From: Shaps Benkau Date: Sat, 6 Jun 2026 00:17:41 +0100 Subject: [PATCH 03/10] Fix API sync workflow and symbol graph parsing Address PR review feedback by checking out the PR head ref in CI, supporting array-based symbol graph payloads, and collecting generated .symbols.json files from .build when output-path flags are unavailable. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .github/scripts/generate-public-api-list.sh | 29 ++++++++++++++++++- .../scripts/generate_public_api_list.swift | 10 +++++-- .github/workflows/public-api-sync.yml | 1 + 3 files changed, 36 insertions(+), 4 deletions(-) diff --git a/.github/scripts/generate-public-api-list.sh b/.github/scripts/generate-public-api-list.sh index 6f3cd192..c0036f8e 100644 --- a/.github/scripts/generate-public-api-list.sh +++ b/.github/scripts/generate-public-api-list.sh @@ -31,7 +31,34 @@ if grep -q -- "--output-path" <<< "${help_text}"; then dump_command+=(--output-path "${symbol_graph_dir}") "${dump_command[@]}" else - "${dump_command[@]}" > "${symbol_graph_dir}/SwiftUIBackports.symbols.json" + before_list="$(mktemp)" + after_list="$(mktemp)" + new_list="$(mktemp)" + cleanup() { + rm -f "${before_list}" "${after_list}" "${new_list}" + } + trap cleanup EXIT + + find "${repo_root}/.build" -type f -name "*.symbols.json" 2>/dev/null | sort > "${before_list}" || true + + "${dump_command[@]}" + + find "${repo_root}/.build" -type f -name "*.symbols.json" 2>/dev/null | sort > "${after_list}" || true + + comm -13 "${before_list}" "${after_list}" > "${new_list}" || true + + if [[ -s "${new_list}" ]]; then + while IFS= read -r symbol_file; do + cp "${symbol_file}" "${symbol_graph_dir}/" + done < "${new_list}" + elif [[ -s "${after_list}" ]]; then + while IFS= read -r symbol_file; do + cp "${symbol_file}" "${symbol_graph_dir}/" + done < "${after_list}" + else + echo "error: dump-symbol-graph did not produce any .symbols.json files" >&2 + exit 1 + fi fi swift "${repo_root}/.github/scripts/generate_public_api_list.swift" \ diff --git a/.github/scripts/generate_public_api_list.swift b/.github/scripts/generate_public_api_list.swift index 7c4f2678..4436f4bd 100644 --- a/.github/scripts/generate_public_api_list.swift +++ b/.github/scripts/generate_public_api_list.swift @@ -258,14 +258,18 @@ private func loadSymbolEntries(from file: URL) -> [SymbolEntry] { fail("Unable to decode JSON in \(file.path)") } - guard let symbols = raw["symbols"] as? [String: Any] else { + let symbolObjects: [[String: Any]] + if let symbols = raw["symbols"] as? [[String: Any]] { + symbolObjects = symbols + } else if let symbolsByIdentifier = raw["symbols"] as? [String: Any] { + symbolObjects = symbolsByIdentifier.compactMap { $0.value as? [String: Any] } + } else { return [] } var output: [SymbolEntry] = [] - for (_, symbolValue) in symbols { - guard let symbol = symbolValue as? [String: Any] else { continue } + for symbol in symbolObjects { guard let accessLevel = symbol["accessLevel"] as? String, accessLevel == "public" || accessLevel == "open" diff --git a/.github/workflows/public-api-sync.yml b/.github/workflows/public-api-sync.yml index 7ab79564..68339afb 100644 --- a/.github/workflows/public-api-sync.yml +++ b/.github/workflows/public-api-sync.yml @@ -21,6 +21,7 @@ jobs: - name: Checkout PR branch uses: actions/checkout@v4 with: + ref: ${{ github.head_ref }} fetch-depth: 0 - name: Regenerate public API list From 0929ca7e60348e9ffab057b66a22b36b0d269883 Mon Sep 17 00:00:00 2001 From: shaps80 <251310+shaps80@users.noreply.github.com> Date: Fri, 5 Jun 2026 23:18:35 +0000 Subject: [PATCH 04/10] Update generated public API list in APIs.md --- APIs.md | 25677 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 25676 insertions(+), 1 deletion(-) diff --git a/APIs.md b/APIs.md index 734524da..69a63c04 100644 --- a/APIs.md +++ b/APIs.md @@ -4,4 +4,25679 @@ This file is auto-generated by `.github/scripts/generate-public-api-list.sh`. ## Public API -_No API entries generated._ +### View Namespace + +- `@MainActor var backport: Backport { get }` + +### Transition Namespace + +- `@MainActor static var backport: Backport { get }` + +### Environment Backports + +- `var backportDismiss: Backport.DismissAction { get }` +- `var backportDynamicTypeSize: Backport.DynamicTypeSize { get set }` +- `var backportHorizontalScrollIndicatorVisibility: Backport.ScrollIndicatorVisibility { get set }` +- `var backportIsPresented: Bool { get }` +- `var backportIsScrollEnabled: Bool { get set }` +- `var backportOpenURL: Backport.OpenURLAction { get set }` +- `var backportRefresh: Backport.RefreshAction? { get set }` +- `@MainActor var backportRequestReview: Backport.RequestReviewAction { get }` +- `var backportScrollDismissesKeyboardMode: Backport.ScrollDismissesKeyboardMode { get set }` +- `var backportVerticalScrollIndicatorVisibility: Backport.ScrollIndicatorVisibility { get set }` +- `var debugDescription: String { get }` + +### Modifiers + +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func != (lhs: Self, rhs: Self) -> Bool` +- `static func ... (maximum: Self) -> PartialRangeThrough` +- `static func ... (maximum: Self) -> PartialRangeThrough` +- `static func ... (minimum: Self) -> PartialRangeFrom` +- `static func ... (minimum: Self) -> PartialRangeFrom` +- `static func ... (minimum: Self, maximum: Self) -> ClosedRange` +- `static func ... (minimum: Self, maximum: Self) -> ClosedRange` +- `static func ..< (maximum: Self) -> PartialRangeUpTo` +- `static func ..< (maximum: Self) -> PartialRangeUpTo` +- `static func ..< (minimum: Self, maximum: Self) -> Range` +- `static func ..< (minimum: Self, maximum: Self) -> Range` +- `static func < (lhs: Backport.PresentationDetent, rhs: Backport.PresentationDetent) -> Bool` +- `static func <= (lhs: Self, rhs: Self) -> Bool` +- `static func <= (lhs: Self, rhs: Self) -> Bool` +- `static func > (lhs: Self, rhs: Self) -> Bool` +- `static func > (lhs: Self, rhs: Self) -> Bool` +- `static func >= (lhs: Self, rhs: Self) -> Bool` +- `static func >= (lhs: Self, rhs: Self) -> Bool` +- `func allSatisfy(_ predicate: (Self.Element) throws -> Bool) rethrows -> Bool` +- `func allSatisfy(_ predicate: (Self.Element) throws -> Bool) rethrows -> Bool` +- `func allSatisfy(_ predicate: (Self.Element) throws -> Bool) rethrows -> Bool` +- `func callAsFunction()` +- `func callAsFunction() async` +- `func callAsFunction(_ url: URL)` +- `func callAsFunction(_ url: URL, completion: @escaping (Bool) -> Void)` +- `func compactMap(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]` +- `func compactMap(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]` +- `func compactMap(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func compare(_ lhs: Comparator.Compared, _ rhs: Comparator.Compared) -> ComparisonResult where Comparator : SortComparator, Comparator == Self.Element` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func compare(_ lhs: Comparator.Compared, _ rhs: Comparator.Compared) -> ComparisonResult where Comparator : SortComparator, Comparator == Self.Element` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func compare(_ lhs: Comparator.Compared, _ rhs: Comparator.Compared) -> ComparisonResult where Comparator : SortComparator, Comparator == Self.Element` +- `func contains(where predicate: (Self.Element) throws -> Bool) rethrows -> Bool` +- `func contains(where predicate: (Self.Element) throws -> Bool) rethrows -> Bool` +- `func contains(where predicate: (Self.Element) throws -> Bool) rethrows -> Bool` +- `func count(where predicate: (Self.Element) throws(E) -> Bool) throws(E) -> Int where E : Error` +- `func count(where predicate: (Self.Element) throws(E) -> Bool) throws(E) -> Int where E : Error` +- `func count(where predicate: (Self.Element) throws(E) -> Bool) throws(E) -> Int where E : Error` +- `@available(iOS 13, tvOS 13, watchOS 6, macOS 10.15, *)` + `func difference(from other: C, by areEquivalent: (C.Element, Self.Element) -> Bool) -> CollectionDifference where C : BidirectionalCollection, Self.Element == C.Element` +- `@available(iOS 13, tvOS 13, watchOS 6, macOS 10.15, *)` + `func difference(from other: C, by areEquivalent: (C.Element, Self.Element) -> Bool) -> CollectionDifference where C : BidirectionalCollection, Self.Element == C.Element` +- `@available(iOS 13, tvOS 13, watchOS 6, macOS 10.15, *)` + `func difference(from other: C, by areEquivalent: (C.Element, Self.Element) -> Bool) -> CollectionDifference where C : BidirectionalCollection, Self.Element == C.Element` +- `func drop(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `func drop(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `func drop(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `func dropFirst(_ k: Int = 1) -> Self.SubSequence` +- `func dropFirst(_ k: Int = 1) -> Self.SubSequence` +- `func dropFirst(_ k: Int = 1) -> Self.SubSequence` +- `func dropLast(_ k: Int) -> Self.SubSequence` +- `func dropLast(_ k: Int) -> Self.SubSequence` +- `func dropLast(_ k: Int) -> Self.SubSequence` +- `func elementsEqual(_ other: OtherSequence, by areEquivalent: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence` +- `func elementsEqual(_ other: OtherSequence, by areEquivalent: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence` +- `func elementsEqual(_ other: OtherSequence, by areEquivalent: (Self.Element, OtherSequence.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence` +- `func enumerated() -> EnumeratedSequence` +- `func enumerated() -> EnumeratedSequence` +- `func enumerated() -> EnumeratedSequence` +- `func filter(_ isIncluded: (Self.Element) throws -> Bool) rethrows -> [Self.Element]` +- `func filter(_ isIncluded: (Self.Element) throws -> Bool) rethrows -> [Self.Element]` +- `func filter(_ isIncluded: (Self.Element) throws -> Bool) rethrows -> [Self.Element]` +- `func first(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?` +- `func first(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?` +- `func first(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?` +- `func firstIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?` +- `func firstIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?` +- `func firstIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?` +- `func flatMap(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]` +- `func flatMap(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]` +- `func flatMap(_ transform: (Self.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]` +- `func flatMap(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence` +- `func flatMap(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence` +- `func flatMap(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence` +- `func forEach(_ body: (Self.Element) throws -> Void) rethrows` +- `func forEach(_ body: (Self.Element) throws -> Void) rethrows` +- `func forEach(_ body: (Self.Element) throws -> Void) rethrows` +- `func formIndex(_ i: inout Self.Index, offsetBy distance: Int)` +- `func formIndex(_ i: inout Self.Index, offsetBy distance: Int)` +- `func formIndex(_ i: inout Self.Index, offsetBy distance: Int)` +- `func formIndex(_ i: inout Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Bool` +- `func formIndex(_ i: inout Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Bool` +- `func formIndex(_ i: inout Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Bool` +- `func formIndex(after i: inout Self.Index)` +- `func formIndex(after i: inout Self.Index)` +- `func formIndex(after i: inout Self.Index)` +- `func formIndex(before i: inout Self.Index)` +- `func formIndex(before i: inout Self.Index)` +- `func formIndex(before i: inout Self.Index)` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func formatted(_ style: S) -> S.FormatOutput where Self == S.FormatInput, S : FormatStyle` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func formatted(_ style: S) -> S.FormatOutput where Self == S.FormatInput, S : FormatStyle` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func formatted(_ style: S) -> S.FormatOutput where Self == S.FormatInput, S : FormatStyle` +- `func hash(into hasher: inout Hasher)` +- `func index(_ i: Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Self.Index?` +- `func index(_ i: Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Self.Index?` +- `func index(_ i: Self.Index, offsetBy distance: Int, limitedBy limit: Self.Index) -> Self.Index?` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `func indices(where predicate: (Self.Element) throws -> Bool) rethrows -> RangeSet` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `func indices(where predicate: (Self.Element) throws -> Bool) rethrows -> RangeSet` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `func indices(where predicate: (Self.Element) throws -> Bool) rethrows -> RangeSet` +- `func labeledContentStyle(_ style: S) -> some View where S : BackportLabeledContentStyle` +- `func last(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?` +- `func last(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?` +- `func last(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Element?` +- `func lastIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?` +- `func lastIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?` +- `func lastIndex(where predicate: (Self.Element) throws -> Bool) rethrows -> Self.Index?` +- `func lexicographicallyPrecedes(_ other: OtherSequence, by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element` +- `func lexicographicallyPrecedes(_ other: OtherSequence, by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element` +- `func lexicographicallyPrecedes(_ other: OtherSequence, by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> Bool where OtherSequence : Sequence, Self.Element == OtherSequence.Element` +- `func makeBody(configuration: Backport.AutomaticLabeledContentStyle.Configuration) -> some View` +- `func makeBody(configuration: Backport.CircularProgressViewStyle.Configuration) -> some View` +- `func makeBody(configuration: Backport.DefaultLabelStyle.Configuration) -> some View` +- `func makeBody(configuration: Backport.DefaultProgressViewStyle.Configuration) -> some View` +- `func makeBody(configuration: Backport.IconOnlyLabelStyle.Configuration) -> some View` +- `func makeBody(configuration: Backport.LinearProgressViewStyle.Configuration) -> some View` +- `func makeBody(configuration: Backport.TitleAndIconLabelStyle.Configuration) -> some View` +- `func makeBody(configuration: Backport.TitleOnlyLabelStyle.Configuration) -> some View` +- `func makeIterator() -> IndexingIterator` +- `func makeIterator() -> IndexingIterator` +- `func makeIterator() -> IndexingIterator` +- `func map(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error` +- `func map(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error` +- `func map(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error` +- `func map(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error` +- `func map(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error` +- `func map(_ transform: (Self.Element) throws(E) -> T) throws(E) -> [T] where E : Error` +- `func onChange(of value: V, initial: Bool = false, _ action: @escaping (V, V) -> Void) -> some View where V : Equatable` +- `func onChange(of value: Value, perform action: @escaping (Value) -> Void) -> some View where Value : Equatable` +- `func prefix(_ maxLength: Int) -> Self.SubSequence` +- `func prefix(_ maxLength: Int) -> Self.SubSequence` +- `func prefix(_ maxLength: Int) -> Self.SubSequence` +- `func prefix(through position: Self.Index) -> Self.SubSequence` +- `func prefix(through position: Self.Index) -> Self.SubSequence` +- `func prefix(through position: Self.Index) -> Self.SubSequence` +- `func prefix(upTo end: Self.Index) -> Self.SubSequence` +- `func prefix(upTo end: Self.Index) -> Self.SubSequence` +- `func prefix(upTo end: Self.Index) -> Self.SubSequence` +- `func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `func prefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `func push(from edge: Edge) -> AnyTransition` +- `func quickLookPreview(_ item: Binding) -> some View` +- `func quickLookPreview(_ selection: Binding, in items: Items) -> some View where Items : RandomAccessCollection, Items.Element == URL` +- `func randomElement() -> Self.Element?` +- `func randomElement() -> Self.Element?` +- `func randomElement() -> Self.Element?` +- `func randomElement(using generator: inout T) -> Self.Element? where T : RandomNumberGenerator` +- `func randomElement(using generator: inout T) -> Self.Element? where T : RandomNumberGenerator` +- `func randomElement(using generator: inout T) -> Self.Element? where T : RandomNumberGenerator` +- `func reduce(_ initialResult: Result, _ nextPartialResult: (Result, Self.Element) throws -> Result) rethrows -> Result` +- `func reduce(_ initialResult: Result, _ nextPartialResult: (Result, Self.Element) throws -> Result) rethrows -> Result` +- `func reduce(_ initialResult: Result, _ nextPartialResult: (Result, Self.Element) throws -> Result) rethrows -> Result` +- `func reduce(into initialResult: Result, _ updateAccumulatingResult: (inout Result, Self.Element) throws -> ()) rethrows -> Result` +- `func reduce(into initialResult: Result, _ updateAccumulatingResult: (inout Result, Self.Element) throws -> ()) rethrows -> Result` +- `func reduce(into initialResult: Result, _ updateAccumulatingResult: (inout Result, Self.Element) throws -> ()) rethrows -> Result` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `func removingSubranges(_ subranges: RangeSet) -> DiscontiguousSlice` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `func removingSubranges(_ subranges: RangeSet) -> DiscontiguousSlice` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `func removingSubranges(_ subranges: RangeSet) -> DiscontiguousSlice` +- `func reversed() -> ReversedCollection` +- `func reversed() -> ReversedCollection` +- `func reversed() -> ReversedCollection` +- `func shuffled() -> [Self.Element]` +- `func shuffled() -> [Self.Element]` +- `func shuffled() -> [Self.Element]` +- `func shuffled(using generator: inout T) -> [Self.Element] where T : RandomNumberGenerator` +- `func shuffled(using generator: inout T) -> [Self.Element] where T : RandomNumberGenerator` +- `func shuffled(using generator: inout T) -> [Self.Element] where T : RandomNumberGenerator` +- `func sorted(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element]` +- `func sorted(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element]` +- `func sorted(by areInIncreasingOrder: (Self.Element, Self.Element) throws -> Bool) rethrows -> [Self.Element]` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func sorted(using comparator: Comparator) -> [Self.Element] where Comparator : SortComparator, Self.Element == Comparator.Compared` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func sorted(using comparator: Comparator) -> [Self.Element] where Comparator : SortComparator, Self.Element == Comparator.Compared` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func sorted(using comparator: Comparator) -> [Self.Element] where Comparator : SortComparator, Self.Element == Comparator.Compared` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func sorted(using comparators: S) -> [Self.Element] where S : Sequence, Comparator : SortComparator, Comparator == S.Element, Self.Element == Comparator.Compared` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func sorted(using comparators: S) -> [Self.Element] where S : Sequence, Comparator : SortComparator, Comparator == S.Element, Self.Element == Comparator.Compared` +- `@available(iOS 15, tvOS 15, watchOS 8, macOS 12, *)` + `func sorted(using comparators: S) -> [Self.Element] where S : Sequence, Comparator : SortComparator, Comparator == S.Element, Self.Element == Comparator.Compared` +- `func split(maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true, whereSeparator isSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence]` +- `func split(maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true, whereSeparator isSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence]` +- `func split(maxSplits: Int = Int.max, omittingEmptySubsequences: Bool = true, whereSeparator isSeparator: (Self.Element) throws -> Bool) rethrows -> [Self.SubSequence]` +- `func starts(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool where PossiblePrefix : Sequence` +- `func starts(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool where PossiblePrefix : Sequence` +- `func starts(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool) rethrows -> Bool where PossiblePrefix : Sequence` +- `@MainActor subscript(bounds: Range) -> Backport.SubviewsCollectionSlice { get }` +- `@MainActor subscript(bounds: Range) -> Backport.SubviewsCollectionSlice { get }` +- `@MainActor subscript(index: Int) -> Backport.Subview { get }` +- `@MainActor subscript(position: Int) -> Backport.Subview { get }` +- `@MainActor subscript(position: Int) -> Backport.Subview { get }` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `subscript(subranges: RangeSet) -> DiscontiguousSlice { get }` +- `@available(iOS 18, tvOS 18, watchOS 11, macOS 15, *)` + `subscript(subranges: RangeSet) -> DiscontiguousSlice { get }` +- `subscript(x: (UnboundedRange_) -> ()) -> Self.SubSequence { get }` +- `subscript(x: (UnboundedRange_) -> ()) -> Self.SubSequence { get }` +- `subscript(r: R) -> Self.SubSequence where R : RangeExpression, Self.Index == R.Bound { get }` +- `subscript(r: R) -> Self.SubSequence where R : RangeExpression, Self.Index == R.Bound { get }` +- `func suffix(_ maxLength: Int) -> Self.SubSequence` +- `func suffix(_ maxLength: Int) -> Self.SubSequence` +- `func suffix(_ maxLength: Int) -> Self.SubSequence` +- `func suffix(from start: Self.Index) -> Self.SubSequence` +- `func suffix(from start: Self.Index) -> Self.SubSequence` +- `func suffix(from start: Self.Index) -> Self.SubSequence` +- `@available(iOS 16, tvOS 16, watchOS 9, macOS 13, *)` + `func trimmingPrefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `@available(iOS 16, tvOS 16, watchOS 9, macOS 13, *)` + `func trimmingPrefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `@available(iOS 16, tvOS 16, watchOS 9, macOS 13, *)` + `func trimmingPrefix(while predicate: (Self.Element) throws -> Bool) rethrows -> Self.SubSequence` +- `func withContiguousStorageIfAvailable(_ body: (UnsafeBufferPointer) throws -> R) rethrows -> R?` +- `func withContiguousStorageIfAvailable(_ body: (UnsafeBufferPointer) throws -> R) rethrows -> R?` +- `func withContiguousStorageIfAvailable(_ body: (UnsafeBufferPointer) throws -> R) rethrows -> R?` + +### Backport Namespace + +- `@ViewBuilder static func AsyncImage(url: URL?, scale: CGFloat = 1) -> some View` +- `@ViewBuilder static func AsyncImage(url: URL?, scale: CGFloat = 1, @ViewBuilder content: @escaping (Image) -> I, @ViewBuilder placeholder: @escaping () -> P) -> some View where I : View, P : View` +- `@ViewBuilder static func AsyncImage(url: URL?, scale: CGFloat = 1, transaction: Transaction = Transaction(), @ViewBuilder content: @escaping (Backport.AsyncImagePhase) -> Content) -> some View where Content : View` +- `@MainActor @propertyWrapper struct AppStorage` +- `enum AsyncImagePhase` +- `case empty` +- `case failure(any Error)` +- `case success(Image)` +- `struct AutomaticLabeledContentStyle` +- `struct CircularProgressViewStyle` +- `@MainActor struct ContentUnavailableView where Label : View, Description : View, Actions : View` +- `struct DefaultLabelStyle` +- `struct DefaultProgressViewStyle` +- `struct DismissAction` +- `enum DynamicTypeSize` +- `case accessibility1` +- `case accessibility2` +- `case accessibility3` +- `case accessibility4` +- `case accessibility5` +- `case large` +- `case medium` +- `case small` +- `case xLarge` +- `case xSmall` +- `case xxLarge` +- `case xxxLarge` +- `@MainActor struct ForEach where Content : View` +- `@MainActor struct ForEachSubviewCollection where Content : View` +- `typealias Element = Backport.Subview` +- `typealias Index = Int` +- `typealias Indices = Range` +- `typealias Iterator = IndexingIterator.ForEachSubviewCollection>` +- `typealias SubSequence = Slice.ForEachSubviewCollection>` +- `@MainActor struct Group where Content : View` +- `@MainActor struct GroupElementsOfContent where Subviews : View, Content : View` +- `struct IconOnlyLabelStyle` +- `final class ImageRenderer where Content : View` +- `@MainActor struct Label where Title : View, Icon : View` +- `struct LabelStyleConfiguration` +- `@MainActor struct LabeledContent` +- `struct LabeledContentStyleConfiguration` +- `struct LinearProgressViewStyle` +- `@MainActor struct Link