Swift Package IndexBuild Information
Successful build of APIota, reference 0.2.0 (590dd9), with Swift 6.0 for Linux on 28 Nov 2024 00:56:20 UTC.
Swift 6 data race errors: 197
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4609320-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1Build Log
53 | public static let certNotAfter = HTTPHeader("Cert-Not-After")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:52:23: warning: static property 'cdnLoop' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
50 | public static let calManagedId = HTTPHeader("Cal-Managed-ID")
51 | public static let calDAVTimezones = HTTPHeader("CalDAV-Timezones")
52 | public static let cdnLoop = HTTPHeader("CDN-Loop")
| |- warning: static property 'cdnLoop' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'cdnLoop' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
53 | public static let certNotAfter = HTTPHeader("Cert-Not-After")
54 | public static let certNotBefore = HTTPHeader("Cert-Not-Before")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:53:23: warning: static property 'certNotAfter' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
51 | public static let calDAVTimezones = HTTPHeader("CalDAV-Timezones")
52 | public static let cdnLoop = HTTPHeader("CDN-Loop")
53 | public static let certNotAfter = HTTPHeader("Cert-Not-After")
| |- warning: static property 'certNotAfter' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'certNotAfter' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
54 | public static let certNotBefore = HTTPHeader("Cert-Not-Before")
55 | public static let close = HTTPHeader("Close")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:54:23: warning: static property 'certNotBefore' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
52 | public static let cdnLoop = HTTPHeader("CDN-Loop")
53 | public static let certNotAfter = HTTPHeader("Cert-Not-After")
54 | public static let certNotBefore = HTTPHeader("Cert-Not-Before")
| |- warning: static property 'certNotBefore' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'certNotBefore' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
55 | public static let close = HTTPHeader("Close")
56 | public static let connection = HTTPHeader("Connection")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:55:23: warning: static property 'close' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
53 | public static let certNotAfter = HTTPHeader("Cert-Not-After")
54 | public static let certNotBefore = HTTPHeader("Cert-Not-Before")
55 | public static let close = HTTPHeader("Close")
| |- warning: static property 'close' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'close' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
56 | public static let connection = HTTPHeader("Connection")
57 | public static let contentBase = HTTPHeader("Content-Base")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:56:23: warning: static property 'connection' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
54 | public static let certNotBefore = HTTPHeader("Cert-Not-Before")
55 | public static let close = HTTPHeader("Close")
56 | public static let connection = HTTPHeader("Connection")
| |- warning: static property 'connection' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'connection' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
57 | public static let contentBase = HTTPHeader("Content-Base")
58 | public static let contentDisposition = HTTPHeader("Content-Disposition")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:57:23: warning: static property 'contentBase' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
55 | public static let close = HTTPHeader("Close")
56 | public static let connection = HTTPHeader("Connection")
57 | public static let contentBase = HTTPHeader("Content-Base")
| |- warning: static property 'contentBase' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentBase' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
58 | public static let contentDisposition = HTTPHeader("Content-Disposition")
59 | public static let contentEncoding = HTTPHeader("Content-Encoding")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:58:23: warning: static property 'contentDisposition' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
56 | public static let connection = HTTPHeader("Connection")
57 | public static let contentBase = HTTPHeader("Content-Base")
58 | public static let contentDisposition = HTTPHeader("Content-Disposition")
| |- warning: static property 'contentDisposition' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentDisposition' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
59 | public static let contentEncoding = HTTPHeader("Content-Encoding")
60 | public static let contentId = HTTPHeader("Content-ID")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:59:23: warning: static property 'contentEncoding' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
57 | public static let contentBase = HTTPHeader("Content-Base")
58 | public static let contentDisposition = HTTPHeader("Content-Disposition")
59 | public static let contentEncoding = HTTPHeader("Content-Encoding")
| |- warning: static property 'contentEncoding' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentEncoding' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
60 | public static let contentId = HTTPHeader("Content-ID")
61 | public static let contentLanguage = HTTPHeader("Content-Language")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:60:23: warning: static property 'contentId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
58 | public static let contentDisposition = HTTPHeader("Content-Disposition")
59 | public static let contentEncoding = HTTPHeader("Content-Encoding")
60 | public static let contentId = HTTPHeader("Content-ID")
| |- warning: static property 'contentId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentId' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
61 | public static let contentLanguage = HTTPHeader("Content-Language")
62 | public static let contentLength = HTTPHeader("Content-Length")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:61:23: warning: static property 'contentLanguage' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
59 | public static let contentEncoding = HTTPHeader("Content-Encoding")
60 | public static let contentId = HTTPHeader("Content-ID")
61 | public static let contentLanguage = HTTPHeader("Content-Language")
| |- warning: static property 'contentLanguage' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentLanguage' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
62 | public static let contentLength = HTTPHeader("Content-Length")
63 | public static let contentLocation = HTTPHeader("Content-Location")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:62:23: warning: static property 'contentLength' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
60 | public static let contentId = HTTPHeader("Content-ID")
61 | public static let contentLanguage = HTTPHeader("Content-Language")
62 | public static let contentLength = HTTPHeader("Content-Length")
| |- warning: static property 'contentLength' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentLength' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
63 | public static let contentLocation = HTTPHeader("Content-Location")
64 | public static let contentMD5 = HTTPHeader("Content-MD5")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:63:23: warning: static property 'contentLocation' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
61 | public static let contentLanguage = HTTPHeader("Content-Language")
62 | public static let contentLength = HTTPHeader("Content-Length")
63 | public static let contentLocation = HTTPHeader("Content-Location")
| |- warning: static property 'contentLocation' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentLocation' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
64 | public static let contentMD5 = HTTPHeader("Content-MD5")
65 | public static let contentRange = HTTPHeader("Content-Range")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:64:23: warning: static property 'contentMD5' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
62 | public static let contentLength = HTTPHeader("Content-Length")
63 | public static let contentLocation = HTTPHeader("Content-Location")
64 | public static let contentMD5 = HTTPHeader("Content-MD5")
| |- warning: static property 'contentMD5' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentMD5' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
65 | public static let contentRange = HTTPHeader("Content-Range")
66 | public static let contentScriptType = HTTPHeader("Content-Script-Type")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:65:23: warning: static property 'contentRange' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
63 | public static let contentLocation = HTTPHeader("Content-Location")
64 | public static let contentMD5 = HTTPHeader("Content-MD5")
65 | public static let contentRange = HTTPHeader("Content-Range")
| |- warning: static property 'contentRange' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentRange' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
66 | public static let contentScriptType = HTTPHeader("Content-Script-Type")
67 | public static let contentStyleType = HTTPHeader("Content-Style-Type")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:66:23: warning: static property 'contentScriptType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
64 | public static let contentMD5 = HTTPHeader("Content-MD5")
65 | public static let contentRange = HTTPHeader("Content-Range")
66 | public static let contentScriptType = HTTPHeader("Content-Script-Type")
| |- warning: static property 'contentScriptType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentScriptType' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
67 | public static let contentStyleType = HTTPHeader("Content-Style-Type")
68 | public static let contentType = HTTPHeader("Content-Type")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:67:23: warning: static property 'contentStyleType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
65 | public static let contentRange = HTTPHeader("Content-Range")
66 | public static let contentScriptType = HTTPHeader("Content-Script-Type")
67 | public static let contentStyleType = HTTPHeader("Content-Style-Type")
| |- warning: static property 'contentStyleType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentStyleType' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
68 | public static let contentType = HTTPHeader("Content-Type")
69 | public static let contentVersion = HTTPHeader("Content-Version")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:68:23: warning: static property 'contentType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
66 | public static let contentScriptType = HTTPHeader("Content-Script-Type")
67 | public static let contentStyleType = HTTPHeader("Content-Style-Type")
68 | public static let contentType = HTTPHeader("Content-Type")
| |- warning: static property 'contentType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentType' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
69 | public static let contentVersion = HTTPHeader("Content-Version")
70 | public static let cookie = HTTPHeader("Cookie")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:69:23: warning: static property 'contentVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
67 | public static let contentStyleType = HTTPHeader("Content-Style-Type")
68 | public static let contentType = HTTPHeader("Content-Type")
69 | public static let contentVersion = HTTPHeader("Content-Version")
| |- warning: static property 'contentVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'contentVersion' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
70 | public static let cookie = HTTPHeader("Cookie")
71 | public static let cookie2 = HTTPHeader("Cookie2")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:70:23: warning: static property 'cookie' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
68 | public static let contentType = HTTPHeader("Content-Type")
69 | public static let contentVersion = HTTPHeader("Content-Version")
70 | public static let cookie = HTTPHeader("Cookie")
| |- warning: static property 'cookie' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'cookie' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
71 | public static let cookie2 = HTTPHeader("Cookie2")
72 | public static let dasl = HTTPHeader("DASL")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:71:23: warning: static property 'cookie2' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
69 | public static let contentVersion = HTTPHeader("Content-Version")
70 | public static let cookie = HTTPHeader("Cookie")
71 | public static let cookie2 = HTTPHeader("Cookie2")
| |- warning: static property 'cookie2' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'cookie2' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
72 | public static let dasl = HTTPHeader("DASL")
73 | public static let dav = HTTPHeader("DAV")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:72:23: warning: static property 'dasl' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
70 | public static let cookie = HTTPHeader("Cookie")
71 | public static let cookie2 = HTTPHeader("Cookie2")
72 | public static let dasl = HTTPHeader("DASL")
| |- warning: static property 'dasl' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'dasl' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
73 | public static let dav = HTTPHeader("DAV")
74 | public static let date = HTTPHeader("Date")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:73:23: warning: static property 'dav' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
71 | public static let cookie2 = HTTPHeader("Cookie2")
72 | public static let dasl = HTTPHeader("DASL")
73 | public static let dav = HTTPHeader("DAV")
| |- warning: static property 'dav' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'dav' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
74 | public static let date = HTTPHeader("Date")
75 | public static let defaultStyle = HTTPHeader("Default-Style")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:74:23: warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
72 | public static let dasl = HTTPHeader("DASL")
73 | public static let dav = HTTPHeader("DAV")
74 | public static let date = HTTPHeader("Date")
| |- warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'date' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
75 | public static let defaultStyle = HTTPHeader("Default-Style")
76 | public static let deltaBase = HTTPHeader("Delta-Base")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:75:23: warning: static property 'defaultStyle' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
73 | public static let dav = HTTPHeader("DAV")
74 | public static let date = HTTPHeader("Date")
75 | public static let defaultStyle = HTTPHeader("Default-Style")
| |- warning: static property 'defaultStyle' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'defaultStyle' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
76 | public static let deltaBase = HTTPHeader("Delta-Base")
77 | public static let depth = HTTPHeader("Depth")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:76:23: warning: static property 'deltaBase' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
74 | public static let date = HTTPHeader("Date")
75 | public static let defaultStyle = HTTPHeader("Default-Style")
76 | public static let deltaBase = HTTPHeader("Delta-Base")
| |- warning: static property 'deltaBase' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'deltaBase' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
77 | public static let depth = HTTPHeader("Depth")
78 | public static let derivedFrom = HTTPHeader("Derived-From")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:77:23: warning: static property 'depth' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
75 | public static let defaultStyle = HTTPHeader("Default-Style")
76 | public static let deltaBase = HTTPHeader("Delta-Base")
77 | public static let depth = HTTPHeader("Depth")
| |- warning: static property 'depth' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'depth' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
78 | public static let derivedFrom = HTTPHeader("Derived-From")
79 | public static let destination = HTTPHeader("Destination")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:78:23: warning: static property 'derivedFrom' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
76 | public static let deltaBase = HTTPHeader("Delta-Base")
77 | public static let depth = HTTPHeader("Depth")
78 | public static let derivedFrom = HTTPHeader("Derived-From")
| |- warning: static property 'derivedFrom' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'derivedFrom' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
79 | public static let destination = HTTPHeader("Destination")
80 | public static let differentialId = HTTPHeader("Differential-ID")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:79:23: warning: static property 'destination' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
77 | public static let depth = HTTPHeader("Depth")
78 | public static let derivedFrom = HTTPHeader("Derived-From")
79 | public static let destination = HTTPHeader("Destination")
| |- warning: static property 'destination' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'destination' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
80 | public static let differentialId = HTTPHeader("Differential-ID")
81 | public static let digest = HTTPHeader("Digest")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:80:23: warning: static property 'differentialId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
78 | public static let derivedFrom = HTTPHeader("Derived-From")
79 | public static let destination = HTTPHeader("Destination")
80 | public static let differentialId = HTTPHeader("Differential-ID")
| |- warning: static property 'differentialId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'differentialId' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
81 | public static let digest = HTTPHeader("Digest")
82 | public static let earlyData = HTTPHeader("Early-Data")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:81:23: warning: static property 'digest' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
79 | public static let destination = HTTPHeader("Destination")
80 | public static let differentialId = HTTPHeader("Differential-ID")
81 | public static let digest = HTTPHeader("Digest")
| |- warning: static property 'digest' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'digest' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
82 | public static let earlyData = HTTPHeader("Early-Data")
83 | public static let eTag = HTTPHeader("ETag")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:82:23: warning: static property 'earlyData' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
80 | public static let differentialId = HTTPHeader("Differential-ID")
81 | public static let digest = HTTPHeader("Digest")
82 | public static let earlyData = HTTPHeader("Early-Data")
| |- warning: static property 'earlyData' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'earlyData' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
83 | public static let eTag = HTTPHeader("ETag")
84 | public static let expect = HTTPHeader("Expect")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:83:23: warning: static property 'eTag' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
81 | public static let digest = HTTPHeader("Digest")
82 | public static let earlyData = HTTPHeader("Early-Data")
83 | public static let eTag = HTTPHeader("ETag")
| |- warning: static property 'eTag' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'eTag' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
84 | public static let expect = HTTPHeader("Expect")
85 | public static let expectCT = HTTPHeader("Expect-CT")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:84:23: warning: static property 'expect' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
82 | public static let earlyData = HTTPHeader("Early-Data")
83 | public static let eTag = HTTPHeader("ETag")
84 | public static let expect = HTTPHeader("Expect")
| |- warning: static property 'expect' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'expect' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
85 | public static let expectCT = HTTPHeader("Expect-CT")
86 | public static let expires = HTTPHeader("Expires")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:85:23: warning: static property 'expectCT' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
83 | public static let eTag = HTTPHeader("ETag")
84 | public static let expect = HTTPHeader("Expect")
85 | public static let expectCT = HTTPHeader("Expect-CT")
| |- warning: static property 'expectCT' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'expectCT' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
86 | public static let expires = HTTPHeader("Expires")
87 | public static let ext = HTTPHeader("Ext")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:86:23: warning: static property 'expires' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
84 | public static let expect = HTTPHeader("Expect")
85 | public static let expectCT = HTTPHeader("Expect-CT")
86 | public static let expires = HTTPHeader("Expires")
| |- warning: static property 'expires' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'expires' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
87 | public static let ext = HTTPHeader("Ext")
88 | public static let forwarded = HTTPHeader("Forwarded")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:87:23: warning: static property 'ext' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
85 | public static let expectCT = HTTPHeader("Expect-CT")
86 | public static let expires = HTTPHeader("Expires")
87 | public static let ext = HTTPHeader("Ext")
| |- warning: static property 'ext' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ext' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
88 | public static let forwarded = HTTPHeader("Forwarded")
89 | public static let from = HTTPHeader("From")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:88:23: warning: static property 'forwarded' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
86 | public static let expires = HTTPHeader("Expires")
87 | public static let ext = HTTPHeader("Ext")
88 | public static let forwarded = HTTPHeader("Forwarded")
| |- warning: static property 'forwarded' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'forwarded' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
89 | public static let from = HTTPHeader("From")
90 | public static let getProfile = HTTPHeader("GetProfile")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:89:23: warning: static property 'from' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
87 | public static let ext = HTTPHeader("Ext")
88 | public static let forwarded = HTTPHeader("Forwarded")
89 | public static let from = HTTPHeader("From")
| |- warning: static property 'from' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'from' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
90 | public static let getProfile = HTTPHeader("GetProfile")
91 | public static let hobareg = HTTPHeader("Hobareg")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:90:23: warning: static property 'getProfile' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
88 | public static let forwarded = HTTPHeader("Forwarded")
89 | public static let from = HTTPHeader("From")
90 | public static let getProfile = HTTPHeader("GetProfile")
| |- warning: static property 'getProfile' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'getProfile' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
91 | public static let hobareg = HTTPHeader("Hobareg")
92 | public static let host = HTTPHeader("Host")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:91:23: warning: static property 'hobareg' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
89 | public static let from = HTTPHeader("From")
90 | public static let getProfile = HTTPHeader("GetProfile")
91 | public static let hobareg = HTTPHeader("Hobareg")
| |- warning: static property 'hobareg' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hobareg' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
92 | public static let host = HTTPHeader("Host")
93 | public static let http2Settings = HTTPHeader("HTTP2-Settings")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:92:23: warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
90 | public static let getProfile = HTTPHeader("GetProfile")
91 | public static let hobareg = HTTPHeader("Hobareg")
92 | public static let host = HTTPHeader("Host")
| |- warning: static property 'host' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'host' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
93 | public static let http2Settings = HTTPHeader("HTTP2-Settings")
94 | // swiftlint:disable:next identifier_name
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:93:23: warning: static property 'http2Settings' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
91 | public static let hobareg = HTTPHeader("Hobareg")
92 | public static let host = HTTPHeader("Host")
93 | public static let http2Settings = HTTPHeader("HTTP2-Settings")
| |- warning: static property 'http2Settings' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'http2Settings' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
94 | // swiftlint:disable:next identifier_name
95 | public static let im = HTTPHeader("IM")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:95:23: warning: static property 'im' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
93 | public static let http2Settings = HTTPHeader("HTTP2-Settings")
94 | // swiftlint:disable:next identifier_name
95 | public static let im = HTTPHeader("IM")
| |- warning: static property 'im' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'im' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
96 | // swiftlint:disable:next identifier_name
97 | public static let `if` = HTTPHeader("If")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:97:23: warning: static property 'if' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
95 | public static let im = HTTPHeader("IM")
96 | // swiftlint:disable:next identifier_name
97 | public static let `if` = HTTPHeader("If")
| |- warning: static property 'if' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'if' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
98 | public static let ifMatch = HTTPHeader("If-Match")
99 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:98:23: warning: static property 'ifMatch' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
96 | // swiftlint:disable:next identifier_name
97 | public static let `if` = HTTPHeader("If")
98 | public static let ifMatch = HTTPHeader("If-Match")
| |- warning: static property 'ifMatch' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ifMatch' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
99 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
100 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:99:23: warning: static property 'ifModifiedSince' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
97 | public static let `if` = HTTPHeader("If")
98 | public static let ifMatch = HTTPHeader("If-Match")
99 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
| |- warning: static property 'ifModifiedSince' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ifModifiedSince' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
100 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
101 | public static let ifRange = HTTPHeader("If-Range")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:100:23: warning: static property 'ifNoneMatch' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
98 | public static let ifMatch = HTTPHeader("If-Match")
99 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
100 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
| |- warning: static property 'ifNoneMatch' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ifNoneMatch' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
101 | public static let ifRange = HTTPHeader("If-Range")
102 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:101:23: warning: static property 'ifRange' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
99 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
100 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
101 | public static let ifRange = HTTPHeader("If-Range")
| |- warning: static property 'ifRange' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ifRange' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
102 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
103 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:102:23: warning: static property 'ifScheduledTagMatch' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
100 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
101 | public static let ifRange = HTTPHeader("If-Range")
102 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
| |- warning: static property 'ifScheduledTagMatch' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ifScheduledTagMatch' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
103 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
104 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:103:23: warning: static property 'ifUnmodifiedSince' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
101 | public static let ifRange = HTTPHeader("If-Range")
102 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
103 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
| |- warning: static property 'ifUnmodifiedSince' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ifUnmodifiedSince' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
104 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
105 | public static let keepAlive = HTTPHeader("Keep-Alive")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:104:23: warning: static property 'includeRefferedTokenBindingId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
102 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
103 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
104 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
| |- warning: static property 'includeRefferedTokenBindingId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'includeRefferedTokenBindingId' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
105 | public static let keepAlive = HTTPHeader("Keep-Alive")
106 | public static let label = HTTPHeader("Label")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:105:23: warning: static property 'keepAlive' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
103 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
104 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
105 | public static let keepAlive = HTTPHeader("Keep-Alive")
| |- warning: static property 'keepAlive' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'keepAlive' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
106 | public static let label = HTTPHeader("Label")
107 | public static let lastModified = HTTPHeader("Last-Modified")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:106:23: warning: static property 'label' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
104 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
105 | public static let keepAlive = HTTPHeader("Keep-Alive")
106 | public static let label = HTTPHeader("Label")
| |- warning: static property 'label' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'label' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
107 | public static let lastModified = HTTPHeader("Last-Modified")
108 | public static let link = HTTPHeader("Link")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:107:23: warning: static property 'lastModified' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
105 | public static let keepAlive = HTTPHeader("Keep-Alive")
106 | public static let label = HTTPHeader("Label")
107 | public static let lastModified = HTTPHeader("Last-Modified")
| |- warning: static property 'lastModified' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'lastModified' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
108 | public static let link = HTTPHeader("Link")
109 | public static let location = HTTPHeader("Location")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:108:23: warning: static property 'link' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
106 | public static let label = HTTPHeader("Label")
107 | public static let lastModified = HTTPHeader("Last-Modified")
108 | public static let link = HTTPHeader("Link")
| |- warning: static property 'link' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'link' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
109 | public static let location = HTTPHeader("Location")
110 | public static let lockToken = HTTPHeader("Lock-Token")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:109:23: warning: static property 'location' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
107 | public static let lastModified = HTTPHeader("Last-Modified")
108 | public static let link = HTTPHeader("Link")
109 | public static let location = HTTPHeader("Location")
| |- warning: static property 'location' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'location' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
110 | public static let lockToken = HTTPHeader("Lock-Token")
111 | public static let man = HTTPHeader("Man")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:110:23: warning: static property 'lockToken' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
108 | public static let link = HTTPHeader("Link")
109 | public static let location = HTTPHeader("Location")
110 | public static let lockToken = HTTPHeader("Lock-Token")
| |- warning: static property 'lockToken' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'lockToken' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
111 | public static let man = HTTPHeader("Man")
112 | public static let maxForwards = HTTPHeader("Max-Forwards")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:111:23: warning: static property 'man' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
109 | public static let location = HTTPHeader("Location")
110 | public static let lockToken = HTTPHeader("Lock-Token")
111 | public static let man = HTTPHeader("Man")
| |- warning: static property 'man' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'man' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
112 | public static let maxForwards = HTTPHeader("Max-Forwards")
113 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:112:23: warning: static property 'maxForwards' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
110 | public static let lockToken = HTTPHeader("Lock-Token")
111 | public static let man = HTTPHeader("Man")
112 | public static let maxForwards = HTTPHeader("Max-Forwards")
| |- warning: static property 'maxForwards' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'maxForwards' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
113 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
114 | public static let meter = HTTPHeader("Meter")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:113:23: warning: static property 'mementoDatetime' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
111 | public static let man = HTTPHeader("Man")
112 | public static let maxForwards = HTTPHeader("Max-Forwards")
113 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
| |- warning: static property 'mementoDatetime' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'mementoDatetime' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
114 | public static let meter = HTTPHeader("Meter")
115 | public static let mimeVersion = HTTPHeader("MIME-Version")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:114:23: warning: static property 'meter' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
112 | public static let maxForwards = HTTPHeader("Max-Forwards")
113 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
114 | public static let meter = HTTPHeader("Meter")
| |- warning: static property 'meter' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'meter' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
115 | public static let mimeVersion = HTTPHeader("MIME-Version")
116 | public static let negotiate = HTTPHeader("Negotiate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:115:23: warning: static property 'mimeVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
113 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
114 | public static let meter = HTTPHeader("Meter")
115 | public static let mimeVersion = HTTPHeader("MIME-Version")
| |- warning: static property 'mimeVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'mimeVersion' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
116 | public static let negotiate = HTTPHeader("Negotiate")
117 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:116:23: warning: static property 'negotiate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
114 | public static let meter = HTTPHeader("Meter")
115 | public static let mimeVersion = HTTPHeader("MIME-Version")
116 | public static let negotiate = HTTPHeader("Negotiate")
| |- warning: static property 'negotiate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'negotiate' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
117 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
118 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:117:23: warning: static property 'oDataEntityId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
115 | public static let mimeVersion = HTTPHeader("MIME-Version")
116 | public static let negotiate = HTTPHeader("Negotiate")
117 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
| |- warning: static property 'oDataEntityId' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'oDataEntityId' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
118 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
119 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:118:23: warning: static property 'oDataIsolation' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
116 | public static let negotiate = HTTPHeader("Negotiate")
117 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
118 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
| |- warning: static property 'oDataIsolation' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'oDataIsolation' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
119 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
120 | public static let oDataVersion = HTTPHeader("OData-Version")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:119:23: warning: static property 'oDataMaxVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
117 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
118 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
119 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
| |- warning: static property 'oDataMaxVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'oDataMaxVersion' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
120 | public static let oDataVersion = HTTPHeader("OData-Version")
121 | public static let opt = HTTPHeader("Opt")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:120:23: warning: static property 'oDataVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
118 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
119 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
120 | public static let oDataVersion = HTTPHeader("OData-Version")
| |- warning: static property 'oDataVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'oDataVersion' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
121 | public static let opt = HTTPHeader("Opt")
122 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:121:23: warning: static property 'opt' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
119 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
120 | public static let oDataVersion = HTTPHeader("OData-Version")
121 | public static let opt = HTTPHeader("Opt")
| |- warning: static property 'opt' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'opt' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
122 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
123 | public static let orderingType = HTTPHeader("Ordering-Type")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:122:23: warning: static property 'optionalWWWAuthenticate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
120 | public static let oDataVersion = HTTPHeader("OData-Version")
121 | public static let opt = HTTPHeader("Opt")
122 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
| |- warning: static property 'optionalWWWAuthenticate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'optionalWWWAuthenticate' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
123 | public static let orderingType = HTTPHeader("Ordering-Type")
124 | public static let origin = HTTPHeader("Origin")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:123:23: warning: static property 'orderingType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
121 | public static let opt = HTTPHeader("Opt")
122 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
123 | public static let orderingType = HTTPHeader("Ordering-Type")
| |- warning: static property 'orderingType' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'orderingType' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
124 | public static let origin = HTTPHeader("Origin")
125 | public static let oscore = HTTPHeader("OSCORE")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:124:23: warning: static property 'origin' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
122 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
123 | public static let orderingType = HTTPHeader("Ordering-Type")
124 | public static let origin = HTTPHeader("Origin")
| |- warning: static property 'origin' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'origin' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
125 | public static let oscore = HTTPHeader("OSCORE")
126 | public static let overwrite = HTTPHeader("Overwrite")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:125:23: warning: static property 'oscore' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
123 | public static let orderingType = HTTPHeader("Ordering-Type")
124 | public static let origin = HTTPHeader("Origin")
125 | public static let oscore = HTTPHeader("OSCORE")
| |- warning: static property 'oscore' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'oscore' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
126 | public static let overwrite = HTTPHeader("Overwrite")
127 | public static let p3p = HTTPHeader("P3P")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:126:23: warning: static property 'overwrite' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
124 | public static let origin = HTTPHeader("Origin")
125 | public static let oscore = HTTPHeader("OSCORE")
126 | public static let overwrite = HTTPHeader("Overwrite")
| |- warning: static property 'overwrite' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'overwrite' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
127 | public static let p3p = HTTPHeader("P3P")
128 | public static let pep = HTTPHeader("PEP")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:127:23: warning: static property 'p3p' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
125 | public static let oscore = HTTPHeader("OSCORE")
126 | public static let overwrite = HTTPHeader("Overwrite")
127 | public static let p3p = HTTPHeader("P3P")
| |- warning: static property 'p3p' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'p3p' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
128 | public static let pep = HTTPHeader("PEP")
129 | public static let picsLabel = HTTPHeader("PICS-Label")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:128:23: warning: static property 'pep' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
126 | public static let overwrite = HTTPHeader("Overwrite")
127 | public static let p3p = HTTPHeader("P3P")
128 | public static let pep = HTTPHeader("PEP")
| |- warning: static property 'pep' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'pep' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
129 | public static let picsLabel = HTTPHeader("PICS-Label")
130 | public static let pepInfo = HTTPHeader("Pep-Info")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:129:23: warning: static property 'picsLabel' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
127 | public static let p3p = HTTPHeader("P3P")
128 | public static let pep = HTTPHeader("PEP")
129 | public static let picsLabel = HTTPHeader("PICS-Label")
| |- warning: static property 'picsLabel' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'picsLabel' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
130 | public static let pepInfo = HTTPHeader("Pep-Info")
131 | public static let position = HTTPHeader("Position")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:130:23: warning: static property 'pepInfo' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
128 | public static let pep = HTTPHeader("PEP")
129 | public static let picsLabel = HTTPHeader("PICS-Label")
130 | public static let pepInfo = HTTPHeader("Pep-Info")
| |- warning: static property 'pepInfo' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'pepInfo' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
131 | public static let position = HTTPHeader("Position")
132 | public static let pragma = HTTPHeader("Pragma")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:131:23: warning: static property 'position' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
129 | public static let picsLabel = HTTPHeader("PICS-Label")
130 | public static let pepInfo = HTTPHeader("Pep-Info")
131 | public static let position = HTTPHeader("Position")
| |- warning: static property 'position' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'position' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
132 | public static let pragma = HTTPHeader("Pragma")
133 | public static let prefer = HTTPHeader("Prefer")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:132:23: warning: static property 'pragma' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
130 | public static let pepInfo = HTTPHeader("Pep-Info")
131 | public static let position = HTTPHeader("Position")
132 | public static let pragma = HTTPHeader("Pragma")
| |- warning: static property 'pragma' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'pragma' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
133 | public static let prefer = HTTPHeader("Prefer")
134 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:133:23: warning: static property 'prefer' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
131 | public static let position = HTTPHeader("Position")
132 | public static let pragma = HTTPHeader("Pragma")
133 | public static let prefer = HTTPHeader("Prefer")
| |- warning: static property 'prefer' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'prefer' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
134 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
135 | public static let profileObject = HTTPHeader("ProfileObject")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:134:23: warning: static property 'preferenceApplied' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
132 | public static let pragma = HTTPHeader("Pragma")
133 | public static let prefer = HTTPHeader("Prefer")
134 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
| |- warning: static property 'preferenceApplied' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'preferenceApplied' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
135 | public static let profileObject = HTTPHeader("ProfileObject")
136 | public static let `protocol` = HTTPHeader("Protocol")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:135:23: warning: static property 'profileObject' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
133 | public static let prefer = HTTPHeader("Prefer")
134 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
135 | public static let profileObject = HTTPHeader("ProfileObject")
| |- warning: static property 'profileObject' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'profileObject' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
136 | public static let `protocol` = HTTPHeader("Protocol")
137 | public static let protocolInfo = HTTPHeader("Protocol-Info")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:136:23: warning: static property 'protocol' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
134 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
135 | public static let profileObject = HTTPHeader("ProfileObject")
136 | public static let `protocol` = HTTPHeader("Protocol")
| |- warning: static property 'protocol' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'protocol' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
137 | public static let protocolInfo = HTTPHeader("Protocol-Info")
138 | public static let protocolQuery = HTTPHeader("Protocol-Query")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:137:23: warning: static property 'protocolInfo' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
135 | public static let profileObject = HTTPHeader("ProfileObject")
136 | public static let `protocol` = HTTPHeader("Protocol")
137 | public static let protocolInfo = HTTPHeader("Protocol-Info")
| |- warning: static property 'protocolInfo' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'protocolInfo' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
138 | public static let protocolQuery = HTTPHeader("Protocol-Query")
139 | public static let protocolRequest = HTTPHeader("Protocol-Request")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:138:23: warning: static property 'protocolQuery' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
136 | public static let `protocol` = HTTPHeader("Protocol")
137 | public static let protocolInfo = HTTPHeader("Protocol-Info")
138 | public static let protocolQuery = HTTPHeader("Protocol-Query")
| |- warning: static property 'protocolQuery' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'protocolQuery' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
139 | public static let protocolRequest = HTTPHeader("Protocol-Request")
140 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:139:23: warning: static property 'protocolRequest' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
137 | public static let protocolInfo = HTTPHeader("Protocol-Info")
138 | public static let protocolQuery = HTTPHeader("Protocol-Query")
139 | public static let protocolRequest = HTTPHeader("Protocol-Request")
| |- warning: static property 'protocolRequest' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'protocolRequest' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
140 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
141 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:140:23: warning: static property 'proxyAuthenticate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
138 | public static let protocolQuery = HTTPHeader("Protocol-Query")
139 | public static let protocolRequest = HTTPHeader("Protocol-Request")
140 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
| |- warning: static property 'proxyAuthenticate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'proxyAuthenticate' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
141 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
142 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:141:23: warning: static property 'proxyAuthenticationInfo' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
139 | public static let protocolRequest = HTTPHeader("Protocol-Request")
140 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
141 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
| |- warning: static property 'proxyAuthenticationInfo' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'proxyAuthenticationInfo' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
142 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
143 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:142:23: warning: static property 'proxyAuthorization' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
140 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
141 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
142 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
| |- warning: static property 'proxyAuthorization' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'proxyAuthorization' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
143 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
144 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:143:23: warning: static property 'proxyFeatures' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
141 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
142 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
143 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
| |- warning: static property 'proxyFeatures' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'proxyFeatures' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
144 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
145 | public static let `public` = HTTPHeader("Public")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:144:23: warning: static property 'proxyInstruction' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
142 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
143 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
144 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
| |- warning: static property 'proxyInstruction' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'proxyInstruction' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
145 | public static let `public` = HTTPHeader("Public")
146 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:145:23: warning: static property 'public' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
143 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
144 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
145 | public static let `public` = HTTPHeader("Public")
| |- warning: static property 'public' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'public' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
146 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
147 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:146:23: warning: static property 'publicKeyPins' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
144 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
145 | public static let `public` = HTTPHeader("Public")
146 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
| |- warning: static property 'publicKeyPins' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'publicKeyPins' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
147 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
148 | public static let range = HTTPHeader("Range")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:147:23: warning: static property 'publicKeyPinsReportOnly' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
145 | public static let `public` = HTTPHeader("Public")
146 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
147 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
| |- warning: static property 'publicKeyPinsReportOnly' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'publicKeyPinsReportOnly' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
148 | public static let range = HTTPHeader("Range")
149 | public static let redirectRef = HTTPHeader("Redirect-Ref")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:148:23: warning: static property 'range' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
146 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
147 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
148 | public static let range = HTTPHeader("Range")
| |- warning: static property 'range' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'range' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
149 | public static let redirectRef = HTTPHeader("Redirect-Ref")
150 | public static let referer = HTTPHeader("Referer")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:149:23: warning: static property 'redirectRef' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
147 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
148 | public static let range = HTTPHeader("Range")
149 | public static let redirectRef = HTTPHeader("Redirect-Ref")
| |- warning: static property 'redirectRef' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'redirectRef' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
150 | public static let referer = HTTPHeader("Referer")
151 | public static let replayNotice = HTTPHeader("Replay-Nonce")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:150:23: warning: static property 'referer' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
148 | public static let range = HTTPHeader("Range")
149 | public static let redirectRef = HTTPHeader("Redirect-Ref")
150 | public static let referer = HTTPHeader("Referer")
| |- warning: static property 'referer' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'referer' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
151 | public static let replayNotice = HTTPHeader("Replay-Nonce")
152 | public static let retryAfter = HTTPHeader("Retry-After")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:151:23: warning: static property 'replayNotice' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
149 | public static let redirectRef = HTTPHeader("Redirect-Ref")
150 | public static let referer = HTTPHeader("Referer")
151 | public static let replayNotice = HTTPHeader("Replay-Nonce")
| |- warning: static property 'replayNotice' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'replayNotice' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
152 | public static let retryAfter = HTTPHeader("Retry-After")
153 | public static let safe = HTTPHeader("Safe")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:152:23: warning: static property 'retryAfter' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
150 | public static let referer = HTTPHeader("Referer")
151 | public static let replayNotice = HTTPHeader("Replay-Nonce")
152 | public static let retryAfter = HTTPHeader("Retry-After")
| |- warning: static property 'retryAfter' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'retryAfter' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
153 | public static let safe = HTTPHeader("Safe")
154 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:153:23: warning: static property 'safe' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
151 | public static let replayNotice = HTTPHeader("Replay-Nonce")
152 | public static let retryAfter = HTTPHeader("Retry-After")
153 | public static let safe = HTTPHeader("Safe")
| |- warning: static property 'safe' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'safe' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
154 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
155 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:154:23: warning: static property 'scheduleReply' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
152 | public static let retryAfter = HTTPHeader("Retry-After")
153 | public static let safe = HTTPHeader("Safe")
154 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
| |- warning: static property 'scheduleReply' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'scheduleReply' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
155 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
156 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:155:23: warning: static property 'scheduleTag' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
153 | public static let safe = HTTPHeader("Safe")
154 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
155 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
| |- warning: static property 'scheduleTag' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'scheduleTag' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
156 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
157 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:156:23: warning: static property 'secTokenBinding' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
154 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
155 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
156 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
| |- warning: static property 'secTokenBinding' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'secTokenBinding' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
157 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
158 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:157:23: warning: static property 'secWebsocketAccept' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
155 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
156 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
157 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
| |- warning: static property 'secWebsocketAccept' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'secWebsocketAccept' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
158 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
159 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:158:23: warning: static property 'secWebsocketExtensions' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
156 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
157 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
158 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
| |- warning: static property 'secWebsocketExtensions' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'secWebsocketExtensions' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
159 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
160 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:159:23: warning: static property 'secWebsocketKey' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
157 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
158 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
159 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
| |- warning: static property 'secWebsocketKey' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'secWebsocketKey' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
160 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
161 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:160:23: warning: static property 'secWebsocketProtocol' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
158 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
159 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
160 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
| |- warning: static property 'secWebsocketProtocol' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'secWebsocketProtocol' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
161 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
162 | public static let securityScheme = HTTPHeader("Security-Scheme")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:161:23: warning: static property 'secWebsocketVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
159 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
160 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
161 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
| |- warning: static property 'secWebsocketVersion' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'secWebsocketVersion' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
162 | public static let securityScheme = HTTPHeader("Security-Scheme")
163 | public static let server = HTTPHeader("Server")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:162:23: warning: static property 'securityScheme' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
160 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
161 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
162 | public static let securityScheme = HTTPHeader("Security-Scheme")
| |- warning: static property 'securityScheme' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'securityScheme' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
163 | public static let server = HTTPHeader("Server")
164 | public static let setCookie = HTTPHeader("Set-Cookie")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:163:23: warning: static property 'server' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
161 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
162 | public static let securityScheme = HTTPHeader("Security-Scheme")
163 | public static let server = HTTPHeader("Server")
| |- warning: static property 'server' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'server' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
164 | public static let setCookie = HTTPHeader("Set-Cookie")
165 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:164:23: warning: static property 'setCookie' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
162 | public static let securityScheme = HTTPHeader("Security-Scheme")
163 | public static let server = HTTPHeader("Server")
164 | public static let setCookie = HTTPHeader("Set-Cookie")
| |- warning: static property 'setCookie' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'setCookie' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
165 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
166 | public static let setProfile = HTTPHeader("SetProfile")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:165:23: warning: static property 'setCookie2' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
163 | public static let server = HTTPHeader("Server")
164 | public static let setCookie = HTTPHeader("Set-Cookie")
165 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
| |- warning: static property 'setCookie2' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'setCookie2' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
166 | public static let setProfile = HTTPHeader("SetProfile")
167 | public static let slug = HTTPHeader("SLUG")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:166:23: warning: static property 'setProfile' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
164 | public static let setCookie = HTTPHeader("Set-Cookie")
165 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
166 | public static let setProfile = HTTPHeader("SetProfile")
| |- warning: static property 'setProfile' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'setProfile' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
167 | public static let slug = HTTPHeader("SLUG")
168 | public static let soapAuction = HTTPHeader("SoapAction")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:167:23: warning: static property 'slug' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
165 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
166 | public static let setProfile = HTTPHeader("SetProfile")
167 | public static let slug = HTTPHeader("SLUG")
| |- warning: static property 'slug' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'slug' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
168 | public static let soapAuction = HTTPHeader("SoapAction")
169 | public static let statusUri = HTTPHeader("Status-URI")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:168:23: warning: static property 'soapAuction' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
166 | public static let setProfile = HTTPHeader("SetProfile")
167 | public static let slug = HTTPHeader("SLUG")
168 | public static let soapAuction = HTTPHeader("SoapAction")
| |- warning: static property 'soapAuction' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'soapAuction' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
169 | public static let statusUri = HTTPHeader("Status-URI")
170 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:169:23: warning: static property 'statusUri' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
167 | public static let slug = HTTPHeader("SLUG")
168 | public static let soapAuction = HTTPHeader("SoapAction")
169 | public static let statusUri = HTTPHeader("Status-URI")
| |- warning: static property 'statusUri' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'statusUri' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
170 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
171 | public static let sunset = HTTPHeader("Sunset")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:170:23: warning: static property 'strictTransportSecurity' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
168 | public static let soapAuction = HTTPHeader("SoapAction")
169 | public static let statusUri = HTTPHeader("Status-URI")
170 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
| |- warning: static property 'strictTransportSecurity' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'strictTransportSecurity' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
171 | public static let sunset = HTTPHeader("Sunset")
172 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:171:23: warning: static property 'sunset' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
169 | public static let statusUri = HTTPHeader("Status-URI")
170 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
171 | public static let sunset = HTTPHeader("Sunset")
| |- warning: static property 'sunset' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'sunset' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
172 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
173 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:172:23: warning: static property 'surrogateCapability' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
170 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
171 | public static let sunset = HTTPHeader("Sunset")
172 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
| |- warning: static property 'surrogateCapability' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'surrogateCapability' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
173 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
174 | public static let tcn = HTTPHeader("TCN")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:173:23: warning: static property 'surrogateControl' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
171 | public static let sunset = HTTPHeader("Sunset")
172 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
173 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
| |- warning: static property 'surrogateControl' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'surrogateControl' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
174 | public static let tcn = HTTPHeader("TCN")
175 | // swiftlint:disable:next identifier_name
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:174:23: warning: static property 'tcn' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
172 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
173 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
174 | public static let tcn = HTTPHeader("TCN")
| |- warning: static property 'tcn' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'tcn' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
175 | // swiftlint:disable:next identifier_name
176 | public static let te = HTTPHeader("TE")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:176:23: warning: static property 'te' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
174 | public static let tcn = HTTPHeader("TCN")
175 | // swiftlint:disable:next identifier_name
176 | public static let te = HTTPHeader("TE")
| |- warning: static property 'te' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'te' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
177 | public static let timeout = HTTPHeader("Timeout")
178 | public static let topic = HTTPHeader("Topic")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:177:23: warning: static property 'timeout' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
175 | // swiftlint:disable:next identifier_name
176 | public static let te = HTTPHeader("TE")
177 | public static let timeout = HTTPHeader("Timeout")
| |- warning: static property 'timeout' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'timeout' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
178 | public static let topic = HTTPHeader("Topic")
179 | public static let trailer = HTTPHeader("Trailer")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:178:23: warning: static property 'topic' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
176 | public static let te = HTTPHeader("TE")
177 | public static let timeout = HTTPHeader("Timeout")
178 | public static let topic = HTTPHeader("Topic")
| |- warning: static property 'topic' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'topic' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
179 | public static let trailer = HTTPHeader("Trailer")
180 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:179:23: warning: static property 'trailer' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
177 | public static let timeout = HTTPHeader("Timeout")
178 | public static let topic = HTTPHeader("Topic")
179 | public static let trailer = HTTPHeader("Trailer")
| |- warning: static property 'trailer' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'trailer' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
180 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
181 | public static let ttl = HTTPHeader("TTL")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:180:23: warning: static property 'transferEncoding' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
178 | public static let topic = HTTPHeader("Topic")
179 | public static let trailer = HTTPHeader("Trailer")
180 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
| |- warning: static property 'transferEncoding' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'transferEncoding' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
181 | public static let ttl = HTTPHeader("TTL")
182 | public static let urgency = HTTPHeader("Urgency")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:181:23: warning: static property 'ttl' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
179 | public static let trailer = HTTPHeader("Trailer")
180 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
181 | public static let ttl = HTTPHeader("TTL")
| |- warning: static property 'ttl' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ttl' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
182 | public static let urgency = HTTPHeader("Urgency")
183 | public static let uri = HTTPHeader("URI")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:182:23: warning: static property 'urgency' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
180 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
181 | public static let ttl = HTTPHeader("TTL")
182 | public static let urgency = HTTPHeader("Urgency")
| |- warning: static property 'urgency' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'urgency' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
183 | public static let uri = HTTPHeader("URI")
184 | public static let upgrade = HTTPHeader("Upgrade")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:183:23: warning: static property 'uri' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
181 | public static let ttl = HTTPHeader("TTL")
182 | public static let urgency = HTTPHeader("Urgency")
183 | public static let uri = HTTPHeader("URI")
| |- warning: static property 'uri' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'uri' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
184 | public static let upgrade = HTTPHeader("Upgrade")
185 | public static let userAgent = HTTPHeader("User-Agent")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:184:23: warning: static property 'upgrade' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
182 | public static let urgency = HTTPHeader("Urgency")
183 | public static let uri = HTTPHeader("URI")
184 | public static let upgrade = HTTPHeader("Upgrade")
| |- warning: static property 'upgrade' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'upgrade' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
185 | public static let userAgent = HTTPHeader("User-Agent")
186 | public static let variantVary = HTTPHeader("Variant-Vary")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:185:23: warning: static property 'userAgent' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
183 | public static let uri = HTTPHeader("URI")
184 | public static let upgrade = HTTPHeader("Upgrade")
185 | public static let userAgent = HTTPHeader("User-Agent")
| |- warning: static property 'userAgent' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'userAgent' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
186 | public static let variantVary = HTTPHeader("Variant-Vary")
187 | public static let vary = HTTPHeader("Vary")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:186:23: warning: static property 'variantVary' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
184 | public static let upgrade = HTTPHeader("Upgrade")
185 | public static let userAgent = HTTPHeader("User-Agent")
186 | public static let variantVary = HTTPHeader("Variant-Vary")
| |- warning: static property 'variantVary' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'variantVary' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
187 | public static let vary = HTTPHeader("Vary")
188 | public static let via = HTTPHeader("Via")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:187:23: warning: static property 'vary' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
185 | public static let userAgent = HTTPHeader("User-Agent")
186 | public static let variantVary = HTTPHeader("Variant-Vary")
187 | public static let vary = HTTPHeader("Vary")
| |- warning: static property 'vary' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'vary' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
188 | public static let via = HTTPHeader("Via")
189 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:188:23: warning: static property 'via' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
186 | public static let variantVary = HTTPHeader("Variant-Vary")
187 | public static let vary = HTTPHeader("Vary")
188 | public static let via = HTTPHeader("Via")
| |- warning: static property 'via' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'via' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
189 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
190 | public static let wantDigest = HTTPHeader("Want-Digest")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:189:23: warning: static property 'wwwAuthenticate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
187 | public static let vary = HTTPHeader("Vary")
188 | public static let via = HTTPHeader("Via")
189 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
| |- warning: static property 'wwwAuthenticate' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'wwwAuthenticate' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
190 | public static let wantDigest = HTTPHeader("Want-Digest")
191 | public static let warning = HTTPHeader("Warning")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:190:23: warning: static property 'wantDigest' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
188 | public static let via = HTTPHeader("Via")
189 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
190 | public static let wantDigest = HTTPHeader("Want-Digest")
| |- warning: static property 'wantDigest' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'wantDigest' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
191 | public static let warning = HTTPHeader("Warning")
192 | public static let xContentTypeOptions = HTTPHeader("X-Content-Type-Options")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:191:23: warning: static property 'warning' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
189 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
190 | public static let wantDigest = HTTPHeader("Want-Digest")
191 | public static let warning = HTTPHeader("Warning")
| |- warning: static property 'warning' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'warning' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
192 | public static let xContentTypeOptions = HTTPHeader("X-Content-Type-Options")
193 | public static let xFrameOptions = HTTPHeader("X-Frame-Options")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:192:23: warning: static property 'xContentTypeOptions' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
190 | public static let wantDigest = HTTPHeader("Want-Digest")
191 | public static let warning = HTTPHeader("Warning")
192 | public static let xContentTypeOptions = HTTPHeader("X-Content-Type-Options")
| |- warning: static property 'xContentTypeOptions' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'xContentTypeOptions' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
193 | public static let xFrameOptions = HTTPHeader("X-Frame-Options")
194 | }
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:193:23: warning: static property 'xFrameOptions' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains all HTTP permanent message header field names,
6 | /// referenced from: https://www.iana.org/assignments/message-headers/message-headers.xhtml
7 | public struct HTTPHeader {
| `- note: consider making struct 'HTTPHeader' conform to the 'Sendable' protocol
8 |
9 | // MARK: Internal variables
:
191 | public static let warning = HTTPHeader("Warning")
192 | public static let xContentTypeOptions = HTTPHeader("X-Content-Type-Options")
193 | public static let xFrameOptions = HTTPHeader("X-Frame-Options")
| |- warning: static property 'xFrameOptions' is not concurrency-safe because non-'Sendable' type 'HTTPHeader' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'xFrameOptions' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
194 | }
195 |
Build complete! (75.92s)
Build complete.
{
"dependencies" : [
{
"identity" : "swiftlint",
"requirement" : {
"range" : [
{
"lower_bound" : "0.43.1",
"upper_bound" : "1.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/realm/SwiftLint"
}
],
"manifest_display_name" : "APIota",
"name" : "APIota",
"path" : "/host/spi-builder-workspace",
"platforms" : [
],
"products" : [
{
"name" : "APIota",
"targets" : [
"APIota"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"swift_languages_versions" : [
"5"
],
"targets" : [
{
"c99name" : "APIotaTests",
"module_type" : "SwiftTarget",
"name" : "APIotaTests",
"path" : "Tests/APIotaTests",
"sources" : [
"APIotaCRUDRequestsTests.swift",
"Model/Todo.swift",
"Network/TestAPIClient.swift",
"Network/TestAPIEndpoints.swift",
"XCTestManifests.swift"
],
"target_dependencies" : [
"APIota"
],
"type" : "test"
},
{
"c99name" : "APIota",
"module_type" : "SwiftTarget",
"name" : "APIota",
"path" : "Sources/APIota",
"product_memberships" : [
"APIota"
],
"sources" : [
"APIotaClient.swift",
"APIotaCodableEndpoint.swift",
"APIotaURLEncodedFormEndpoint.swift",
"Error/APIotaClientError.swift",
"HTTP/HTTPHeader.swift",
"HTTP/HTTPHeaders.swift",
"HTTP/HTTPMediaType.swift",
"HTTP/HTTPMethod.swift",
"HTTP/HTTPStatusCode.swift"
],
"type" : "library"
}
],
"tools_version" : "5.2"
}
basic-6.0-latest: Pulling from finestructure/spi-images
Digest: sha256:47d26c99ca4f1ac0a332c85fd5b13ff4390e72115219984a57a68fe9d1063a05
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.0-latest
Done.