Swift Package IndexBuild Information
Successful build of APIota with Swift 6.0 for Linux.
Swift 6 data race errors: 197
Build Command
bash -c docker run --rm -v "checkouts-4609320-0":/host -w "$workDir" 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 2>&1Build Log
| |- 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 | public static let im = HTTPHeader("IM")
/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 | public static let im = HTTPHeader("IM")
95 | public static let `if` = HTTPHeader("If")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:94: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
:
92 | public static let host = HTTPHeader("Host")
93 | public static let http2Settings = HTTPHeader("HTTP2-Settings")
94 | 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
95 | public static let `if` = HTTPHeader("If")
96 | public static let ifMatch = HTTPHeader("If-Match")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:95: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
:
93 | public static let http2Settings = HTTPHeader("HTTP2-Settings")
94 | public static let im = HTTPHeader("IM")
95 | 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
96 | public static let ifMatch = HTTPHeader("If-Match")
97 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:96: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
:
94 | public static let im = HTTPHeader("IM")
95 | public static let `if` = HTTPHeader("If")
96 | 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
97 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
98 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:97: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
:
95 | public static let `if` = HTTPHeader("If")
96 | public static let ifMatch = HTTPHeader("If-Match")
97 | 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
98 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
99 | public static let ifRange = HTTPHeader("If-Range")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:98: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
:
96 | public static let ifMatch = HTTPHeader("If-Match")
97 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
98 | 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
99 | public static let ifRange = HTTPHeader("If-Range")
100 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:99: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
:
97 | public static let ifModifiedSince = HTTPHeader("If-Modified-Since")
98 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
99 | 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
100 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
101 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:100: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
:
98 | public static let ifNoneMatch = HTTPHeader("If-None-Match")
99 | public static let ifRange = HTTPHeader("If-Range")
100 | 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
101 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
102 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:101: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
:
99 | public static let ifRange = HTTPHeader("If-Range")
100 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
101 | 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
102 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
103 | public static let keepAlive = HTTPHeader("Keep-Alive")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:102: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
:
100 | public static let ifScheduledTagMatch = HTTPHeader("If-Schedule-Tag-Match")
101 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
102 | 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
103 | public static let keepAlive = HTTPHeader("Keep-Alive")
104 | public static let label = HTTPHeader("Label")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:103: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
:
101 | public static let ifUnmodifiedSince = HTTPHeader("If-Unmodified-Since")
102 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
103 | 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
104 | public static let label = HTTPHeader("Label")
105 | public static let lastModified = HTTPHeader("Last-Modified")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:104: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
:
102 | public static let includeRefferedTokenBindingId = HTTPHeader("Include-Referred-Token-Binding-ID")
103 | public static let keepAlive = HTTPHeader("Keep-Alive")
104 | 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
105 | public static let lastModified = HTTPHeader("Last-Modified")
106 | public static let link = HTTPHeader("Link")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:105: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
:
103 | public static let keepAlive = HTTPHeader("Keep-Alive")
104 | public static let label = HTTPHeader("Label")
105 | 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
106 | public static let link = HTTPHeader("Link")
107 | public static let location = HTTPHeader("Location")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:106: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
:
104 | public static let label = HTTPHeader("Label")
105 | public static let lastModified = HTTPHeader("Last-Modified")
106 | 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
107 | public static let location = HTTPHeader("Location")
108 | public static let lockToken = HTTPHeader("Lock-Token")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:107: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
:
105 | public static let lastModified = HTTPHeader("Last-Modified")
106 | public static let link = HTTPHeader("Link")
107 | 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
108 | public static let lockToken = HTTPHeader("Lock-Token")
109 | public static let man = HTTPHeader("Man")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:108: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
:
106 | public static let link = HTTPHeader("Link")
107 | public static let location = HTTPHeader("Location")
108 | 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
109 | public static let man = HTTPHeader("Man")
110 | public static let maxForwards = HTTPHeader("Max-Forwards")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:109: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
:
107 | public static let location = HTTPHeader("Location")
108 | public static let lockToken = HTTPHeader("Lock-Token")
109 | 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
110 | public static let maxForwards = HTTPHeader("Max-Forwards")
111 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:110: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
:
108 | public static let lockToken = HTTPHeader("Lock-Token")
109 | public static let man = HTTPHeader("Man")
110 | 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
111 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
112 | public static let meter = HTTPHeader("Meter")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:111: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
:
109 | public static let man = HTTPHeader("Man")
110 | public static let maxForwards = HTTPHeader("Max-Forwards")
111 | 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
112 | public static let meter = HTTPHeader("Meter")
113 | public static let mimeVersion = HTTPHeader("MIME-Version")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:112: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
:
110 | public static let maxForwards = HTTPHeader("Max-Forwards")
111 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
112 | 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
113 | public static let mimeVersion = HTTPHeader("MIME-Version")
114 | public static let negotiate = HTTPHeader("Negotiate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:113: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
:
111 | public static let mementoDatetime = HTTPHeader("Memento-Datetime")
112 | public static let meter = HTTPHeader("Meter")
113 | 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
114 | public static let negotiate = HTTPHeader("Negotiate")
115 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:114: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
:
112 | public static let meter = HTTPHeader("Meter")
113 | public static let mimeVersion = HTTPHeader("MIME-Version")
114 | 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
115 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
116 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:115: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
:
113 | public static let mimeVersion = HTTPHeader("MIME-Version")
114 | public static let negotiate = HTTPHeader("Negotiate")
115 | 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
116 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
117 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:116: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
:
114 | public static let negotiate = HTTPHeader("Negotiate")
115 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
116 | 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
117 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
118 | public static let oDataVersion = HTTPHeader("OData-Version")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:117: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
:
115 | public static let oDataEntityId = HTTPHeader("OData-EntityId")
116 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
117 | 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
118 | public static let oDataVersion = HTTPHeader("OData-Version")
119 | public static let opt = HTTPHeader("Opt")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:118: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
:
116 | public static let oDataIsolation = HTTPHeader("OData-Isolation")
117 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
118 | 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
119 | public static let opt = HTTPHeader("Opt")
120 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:119: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
:
117 | public static let oDataMaxVersion = HTTPHeader("OData-MaxVersion")
118 | public static let oDataVersion = HTTPHeader("OData-Version")
119 | 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
120 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
121 | public static let orderingType = HTTPHeader("Ordering-Type")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:120: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
:
118 | public static let oDataVersion = HTTPHeader("OData-Version")
119 | public static let opt = HTTPHeader("Opt")
120 | 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
121 | public static let orderingType = HTTPHeader("Ordering-Type")
122 | public static let origin = HTTPHeader("Origin")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:121: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
:
119 | public static let opt = HTTPHeader("Opt")
120 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
121 | 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
122 | public static let origin = HTTPHeader("Origin")
123 | public static let oscore = HTTPHeader("OSCORE")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:122: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
:
120 | public static let optionalWWWAuthenticate = HTTPHeader("Optional-WWW-Authenticate")
121 | public static let orderingType = HTTPHeader("Ordering-Type")
122 | 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
123 | public static let oscore = HTTPHeader("OSCORE")
124 | public static let overwrite = HTTPHeader("Overwrite")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:123: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
:
121 | public static let orderingType = HTTPHeader("Ordering-Type")
122 | public static let origin = HTTPHeader("Origin")
123 | 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
124 | public static let overwrite = HTTPHeader("Overwrite")
125 | public static let p3p = HTTPHeader("P3P")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:124: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
:
122 | public static let origin = HTTPHeader("Origin")
123 | public static let oscore = HTTPHeader("OSCORE")
124 | 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
125 | public static let p3p = HTTPHeader("P3P")
126 | public static let pep = HTTPHeader("PEP")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:125: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
:
123 | public static let oscore = HTTPHeader("OSCORE")
124 | public static let overwrite = HTTPHeader("Overwrite")
125 | 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
126 | public static let pep = HTTPHeader("PEP")
127 | public static let picsLabel = HTTPHeader("PICS-Label")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:126: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
:
124 | public static let overwrite = HTTPHeader("Overwrite")
125 | public static let p3p = HTTPHeader("P3P")
126 | 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
127 | public static let picsLabel = HTTPHeader("PICS-Label")
128 | public static let pepInfo = HTTPHeader("Pep-Info")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:127: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
:
125 | public static let p3p = HTTPHeader("P3P")
126 | public static let pep = HTTPHeader("PEP")
127 | 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
128 | public static let pepInfo = HTTPHeader("Pep-Info")
129 | public static let position = HTTPHeader("Position")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:128: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
:
126 | public static let pep = HTTPHeader("PEP")
127 | public static let picsLabel = HTTPHeader("PICS-Label")
128 | 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
129 | public static let position = HTTPHeader("Position")
130 | public static let pragma = HTTPHeader("Pragma")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:129: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
:
127 | public static let picsLabel = HTTPHeader("PICS-Label")
128 | public static let pepInfo = HTTPHeader("Pep-Info")
129 | 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
130 | public static let pragma = HTTPHeader("Pragma")
131 | public static let prefer = HTTPHeader("Prefer")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:130: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
:
128 | public static let pepInfo = HTTPHeader("Pep-Info")
129 | public static let position = HTTPHeader("Position")
130 | 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
131 | public static let prefer = HTTPHeader("Prefer")
132 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:131: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
:
129 | public static let position = HTTPHeader("Position")
130 | public static let pragma = HTTPHeader("Pragma")
131 | 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
132 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
133 | public static let profileObject = HTTPHeader("ProfileObject")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:132: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
:
130 | public static let pragma = HTTPHeader("Pragma")
131 | public static let prefer = HTTPHeader("Prefer")
132 | 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
133 | public static let profileObject = HTTPHeader("ProfileObject")
134 | public static let `protocol` = HTTPHeader("Protocol")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:133: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
:
131 | public static let prefer = HTTPHeader("Prefer")
132 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
133 | 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
134 | public static let `protocol` = HTTPHeader("Protocol")
135 | public static let protocolInfo = HTTPHeader("Protocol-Info")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:134: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
:
132 | public static let preferenceApplied = HTTPHeader("Preference-Applied")
133 | public static let profileObject = HTTPHeader("ProfileObject")
134 | 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
135 | public static let protocolInfo = HTTPHeader("Protocol-Info")
136 | public static let protocolQuery = HTTPHeader("Protocol-Query")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:135: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
:
133 | public static let profileObject = HTTPHeader("ProfileObject")
134 | public static let `protocol` = HTTPHeader("Protocol")
135 | 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
136 | public static let protocolQuery = HTTPHeader("Protocol-Query")
137 | public static let protocolRequest = HTTPHeader("Protocol-Request")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:136: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
:
134 | public static let `protocol` = HTTPHeader("Protocol")
135 | public static let protocolInfo = HTTPHeader("Protocol-Info")
136 | 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
137 | public static let protocolRequest = HTTPHeader("Protocol-Request")
138 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:137: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
:
135 | public static let protocolInfo = HTTPHeader("Protocol-Info")
136 | public static let protocolQuery = HTTPHeader("Protocol-Query")
137 | 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
138 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
139 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:138: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
:
136 | public static let protocolQuery = HTTPHeader("Protocol-Query")
137 | public static let protocolRequest = HTTPHeader("Protocol-Request")
138 | 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
139 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
140 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:139: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
:
137 | public static let protocolRequest = HTTPHeader("Protocol-Request")
138 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
139 | 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
140 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
141 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:140: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
:
138 | public static let proxyAuthenticate = HTTPHeader("Proxy-Authenticate")
139 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
140 | 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
141 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
142 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:141: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
:
139 | public static let proxyAuthenticationInfo = HTTPHeader("Proxy-Authentication-Info")
140 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
141 | 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
142 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
143 | public static let `public` = HTTPHeader("Public")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:142: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
:
140 | public static let proxyAuthorization = HTTPHeader("Proxy-Authorization")
141 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
142 | 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
143 | public static let `public` = HTTPHeader("Public")
144 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:143: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
:
141 | public static let proxyFeatures = HTTPHeader("Proxy-Features")
142 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
143 | 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
144 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
145 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:144: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
:
142 | public static let proxyInstruction = HTTPHeader("Proxy-Instruction")
143 | public static let `public` = HTTPHeader("Public")
144 | 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
145 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
146 | public static let range = HTTPHeader("Range")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:145: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
:
143 | public static let `public` = HTTPHeader("Public")
144 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
145 | 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
146 | public static let range = HTTPHeader("Range")
147 | public static let redirectRef = HTTPHeader("Redirect-Ref")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:146: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
:
144 | public static let publicKeyPins = HTTPHeader("Public-Key-Pins")
145 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
146 | 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
147 | public static let redirectRef = HTTPHeader("Redirect-Ref")
148 | public static let referer = HTTPHeader("Referer")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:147: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
:
145 | public static let publicKeyPinsReportOnly = HTTPHeader("Public-Key-Pins-Report-Only")
146 | public static let range = HTTPHeader("Range")
147 | 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
148 | public static let referer = HTTPHeader("Referer")
149 | public static let replayNotice = HTTPHeader("Replay-Nonce")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:148: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
:
146 | public static let range = HTTPHeader("Range")
147 | public static let redirectRef = HTTPHeader("Redirect-Ref")
148 | 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
149 | public static let replayNotice = HTTPHeader("Replay-Nonce")
150 | public static let retryAfter = HTTPHeader("Retry-After")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:149: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
:
147 | public static let redirectRef = HTTPHeader("Redirect-Ref")
148 | public static let referer = HTTPHeader("Referer")
149 | 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
150 | public static let retryAfter = HTTPHeader("Retry-After")
151 | public static let safe = HTTPHeader("Safe")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:150: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
:
148 | public static let referer = HTTPHeader("Referer")
149 | public static let replayNotice = HTTPHeader("Replay-Nonce")
150 | 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
151 | public static let safe = HTTPHeader("Safe")
152 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:151: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
:
149 | public static let replayNotice = HTTPHeader("Replay-Nonce")
150 | public static let retryAfter = HTTPHeader("Retry-After")
151 | 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
152 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
153 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:152: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
:
150 | public static let retryAfter = HTTPHeader("Retry-After")
151 | public static let safe = HTTPHeader("Safe")
152 | 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
153 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
154 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:153: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
:
151 | public static let safe = HTTPHeader("Safe")
152 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
153 | 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
154 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
155 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:154: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
:
152 | public static let scheduleReply = HTTPHeader("Schedule-Reply")
153 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
154 | 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
155 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
156 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:155: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
:
153 | public static let scheduleTag = HTTPHeader("Schedule-Tag")
154 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
155 | 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
156 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
157 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:156: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
:
154 | public static let secTokenBinding = HTTPHeader("Sec-Token-Binding")
155 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
156 | 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
157 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
158 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:157: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
:
155 | public static let secWebsocketAccept = HTTPHeader("Sec-WebSocket-Accept")
156 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
157 | 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
158 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
159 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:158: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
:
156 | public static let secWebsocketExtensions = HTTPHeader("Sec-WebSocket-Extensions")
157 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
158 | 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
159 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
160 | public static let securityScheme = HTTPHeader("Security-Scheme")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:159: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
:
157 | public static let secWebsocketKey = HTTPHeader("Sec-WebSocket-Key")
158 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
159 | 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
160 | public static let securityScheme = HTTPHeader("Security-Scheme")
161 | public static let server = HTTPHeader("Server")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:160: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
:
158 | public static let secWebsocketProtocol = HTTPHeader("Sec-WebSocket-Protocol")
159 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
160 | 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
161 | public static let server = HTTPHeader("Server")
162 | public static let setCookie = HTTPHeader("Set-Cookie")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:161: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
:
159 | public static let secWebsocketVersion = HTTPHeader("Sec-WebSocket-Version")
160 | public static let securityScheme = HTTPHeader("Security-Scheme")
161 | 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
162 | public static let setCookie = HTTPHeader("Set-Cookie")
163 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:162: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
:
160 | public static let securityScheme = HTTPHeader("Security-Scheme")
161 | public static let server = HTTPHeader("Server")
162 | 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
163 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
164 | public static let setProfile = HTTPHeader("SetProfile")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:163: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
:
161 | public static let server = HTTPHeader("Server")
162 | public static let setCookie = HTTPHeader("Set-Cookie")
163 | 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
164 | public static let setProfile = HTTPHeader("SetProfile")
165 | public static let slug = HTTPHeader("SLUG")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:164: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
:
162 | public static let setCookie = HTTPHeader("Set-Cookie")
163 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
164 | 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
165 | public static let slug = HTTPHeader("SLUG")
166 | public static let soapAuction = HTTPHeader("SoapAction")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:165: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
:
163 | public static let setCookie2 = HTTPHeader("Set-Cookie2")
164 | public static let setProfile = HTTPHeader("SetProfile")
165 | 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
166 | public static let soapAuction = HTTPHeader("SoapAction")
167 | public static let statusUri = HTTPHeader("Status-URI")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:166: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
:
164 | public static let setProfile = HTTPHeader("SetProfile")
165 | public static let slug = HTTPHeader("SLUG")
166 | 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
167 | public static let statusUri = HTTPHeader("Status-URI")
168 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:167: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
:
165 | public static let slug = HTTPHeader("SLUG")
166 | public static let soapAuction = HTTPHeader("SoapAction")
167 | 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
168 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
169 | public static let sunset = HTTPHeader("Sunset")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:168: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
:
166 | public static let soapAuction = HTTPHeader("SoapAction")
167 | public static let statusUri = HTTPHeader("Status-URI")
168 | 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
169 | public static let sunset = HTTPHeader("Sunset")
170 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:169: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
:
167 | public static let statusUri = HTTPHeader("Status-URI")
168 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
169 | 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
170 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
171 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:170: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
:
168 | public static let strictTransportSecurity = HTTPHeader("Strict-Transport-Security")
169 | public static let sunset = HTTPHeader("Sunset")
170 | 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
171 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
172 | public static let tcn = HTTPHeader("TCN")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:171: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
:
169 | public static let sunset = HTTPHeader("Sunset")
170 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
171 | 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
172 | public static let tcn = HTTPHeader("TCN")
173 | public static let te = HTTPHeader("TE")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:172: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
:
170 | public static let surrogateCapability = HTTPHeader("Surrogate-Capability")
171 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
172 | 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
173 | public static let te = HTTPHeader("TE")
174 | public static let timeout = HTTPHeader("Timeout")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:173: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
:
171 | public static let surrogateControl = HTTPHeader("Surrogate-Control")
172 | public static let tcn = HTTPHeader("TCN")
173 | 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
174 | public static let timeout = HTTPHeader("Timeout")
175 | public static let topic = HTTPHeader("Topic")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:174: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
:
172 | public static let tcn = HTTPHeader("TCN")
173 | public static let te = HTTPHeader("TE")
174 | 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
175 | public static let topic = HTTPHeader("Topic")
176 | public static let trailer = HTTPHeader("Trailer")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:175: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
:
173 | public static let te = HTTPHeader("TE")
174 | public static let timeout = HTTPHeader("Timeout")
175 | 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
176 | public static let trailer = HTTPHeader("Trailer")
177 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:176: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
:
174 | public static let timeout = HTTPHeader("Timeout")
175 | public static let topic = HTTPHeader("Topic")
176 | 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
177 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
178 | public static let ttl = HTTPHeader("TTL")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:177: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
:
175 | public static let topic = HTTPHeader("Topic")
176 | public static let trailer = HTTPHeader("Trailer")
177 | 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
178 | public static let ttl = HTTPHeader("TTL")
179 | public static let urgency = HTTPHeader("Urgency")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:178: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
:
176 | public static let trailer = HTTPHeader("Trailer")
177 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
178 | 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
179 | public static let urgency = HTTPHeader("Urgency")
180 | public static let uri = HTTPHeader("URI")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:179: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
:
177 | public static let transferEncoding = HTTPHeader("Transfer-Encoding")
178 | public static let ttl = HTTPHeader("TTL")
179 | 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
180 | public static let uri = HTTPHeader("URI")
181 | public static let upgrade = HTTPHeader("Upgrade")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:180: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
:
178 | public static let ttl = HTTPHeader("TTL")
179 | public static let urgency = HTTPHeader("Urgency")
180 | 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
181 | public static let upgrade = HTTPHeader("Upgrade")
182 | public static let userAgent = HTTPHeader("User-Agent")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:181: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
:
179 | public static let urgency = HTTPHeader("Urgency")
180 | public static let uri = HTTPHeader("URI")
181 | 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
182 | public static let userAgent = HTTPHeader("User-Agent")
183 | public static let variantVary = HTTPHeader("Variant-Vary")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:182: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
:
180 | public static let uri = HTTPHeader("URI")
181 | public static let upgrade = HTTPHeader("Upgrade")
182 | 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
183 | public static let variantVary = HTTPHeader("Variant-Vary")
184 | public static let vary = HTTPHeader("Vary")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:183: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
:
181 | public static let upgrade = HTTPHeader("Upgrade")
182 | public static let userAgent = HTTPHeader("User-Agent")
183 | 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
184 | public static let vary = HTTPHeader("Vary")
185 | public static let via = HTTPHeader("Via")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:184: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
:
182 | public static let userAgent = HTTPHeader("User-Agent")
183 | public static let variantVary = HTTPHeader("Variant-Vary")
184 | 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
185 | public static let via = HTTPHeader("Via")
186 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:185: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
:
183 | public static let variantVary = HTTPHeader("Variant-Vary")
184 | public static let vary = HTTPHeader("Vary")
185 | 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
186 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
187 | public static let wantDigest = HTTPHeader("Want-Digest")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:186: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
:
184 | public static let vary = HTTPHeader("Vary")
185 | public static let via = HTTPHeader("Via")
186 | 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
187 | public static let wantDigest = HTTPHeader("Want-Digest")
188 | public static let warning = HTTPHeader("Warning")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:187: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
:
185 | public static let via = HTTPHeader("Via")
186 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
187 | 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
188 | public static let warning = HTTPHeader("Warning")
189 | public static let xContentTypeOptions = HTTPHeader("X-Content-Type-Options")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:188: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
:
186 | public static let wwwAuthenticate = HTTPHeader("WWW-Authenticate")
187 | public static let wantDigest = HTTPHeader("Want-Digest")
188 | 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
189 | public static let xContentTypeOptions = HTTPHeader("X-Content-Type-Options")
190 | public static let xFrameOptions = HTTPHeader("X-Frame-Options")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:189: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
:
187 | public static let wantDigest = HTTPHeader("Want-Digest")
188 | public static let warning = HTTPHeader("Warning")
189 | 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
190 | public static let xFrameOptions = HTTPHeader("X-Frame-Options")
191 | }
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPHeader.swift:190: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
:
188 | public static let warning = HTTPHeader("Warning")
189 | public static let xContentTypeOptions = HTTPHeader("X-Content-Type-Options")
190 | 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
191 | }
192 |
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:92:16: warning: static property 'any' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
90 | // any
91 |
92 | static let any = HTTPMediaType(type: .any, subType: "*")
| |- warning: static property 'any' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'any' 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 |
94 | // application
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:96:16: warning: static property 'binary' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
94 | // application
95 |
96 | static let binary = HTTPMediaType(type: .application, subType: "octet-stream")
| |- warning: static property 'binary' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'binary' 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
97 |
98 | static let bzip2 = HTTPMediaType(type: .application, subType: "x-bzip2")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:98:16: warning: static property 'bzip2' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
96 | static let binary = HTTPMediaType(type: .application, subType: "octet-stream")
97 |
98 | static let bzip2 = HTTPMediaType(type: .application, subType: "x-bzip2")
| |- warning: static property 'bzip2' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'bzip2' 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 |
100 | static let gzip = HTTPMediaType(type: .application, subType: "x-bzip2")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:100:16: warning: static property 'gzip' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
98 | static let bzip2 = HTTPMediaType(type: .application, subType: "x-bzip2")
99 |
100 | static let gzip = HTTPMediaType(type: .application, subType: "x-bzip2")
| |- warning: static property 'gzip' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'gzip' 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 |
102 | static let dtd = HTTPMediaType(type: .application,
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:102:16: warning: static property 'dtd' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
100 | static let gzip = HTTPMediaType(type: .application, subType: "x-bzip2")
101 |
102 | static let dtd = HTTPMediaType(type: .application,
| |- warning: static property 'dtd' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'dtd' 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 | subType: "xml-dtd",
104 | parameters: utf8CharsetParameter)
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:106:16: warning: static property 'json' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
104 | parameters: utf8CharsetParameter)
105 |
106 | static let json = HTTPMediaType(type: .application, subType: "json")
| |- warning: static property 'json' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'json' 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 |
108 | static let jsonAPI = HTTPMediaType(type: .application,
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:108:16: warning: static property 'jsonAPI' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
106 | static let json = HTTPMediaType(type: .application, subType: "json")
107 |
108 | static let jsonAPI = HTTPMediaType(type: .application,
| |- warning: static property 'jsonAPI' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'jsonAPI' 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 | subType: "vnd.api+json",
110 | parameters: utf8CharsetParameter)
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:112:16: warning: static property 'pdf' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
110 | parameters: utf8CharsetParameter)
111 |
112 | static let pdf = HTTPMediaType(type: .application, subType: "pdf")
| |- warning: static property 'pdf' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'pdf' 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 |
114 | static let tar = HTTPMediaType(type: .application, subType: "x-tar")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:114:16: warning: static property 'tar' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
112 | static let pdf = HTTPMediaType(type: .application, subType: "pdf")
113 |
114 | static let tar = HTTPMediaType(type: .application, subType: "x-tar")
| |- warning: static property 'tar' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'tar' 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 |
116 | static let urlEncodedForm = HTTPMediaType(type: .application,
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:116:16: warning: static property 'urlEncodedForm' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
114 | static let tar = HTTPMediaType(type: .application, subType: "x-tar")
115 |
116 | static let urlEncodedForm = HTTPMediaType(type: .application,
| |- warning: static property 'urlEncodedForm' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'urlEncodedForm' 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 | subType: "x-www-form-urlencoded",
118 | parameters: utf8CharsetParameter)
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:120:16: warning: static property 'xml' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
118 | parameters: utf8CharsetParameter)
119 |
120 | static let xml = HTTPMediaType(type: .application,
| |- warning: static property 'xml' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'xml' 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 | subType: "xml",
122 | parameters: utf8CharsetParameter)
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:124:16: warning: static property 'zip' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
122 | parameters: utf8CharsetParameter)
123 |
124 | static let zip = HTTPMediaType(type: .application, subType: "zip")
| |- warning: static property 'zip' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'zip' 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 |
126 | // audio
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:128:16: warning: static property 'audio' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
126 | // audio
127 |
128 | static let audio = HTTPMediaType(type: .audio, subType: "basic")
| |- warning: static property 'audio' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'audio' 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 |
130 | static let midi = HTTPMediaType(type: .audio, subType: "x-midi")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:130:16: warning: static property 'midi' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
128 | static let audio = HTTPMediaType(type: .audio, subType: "basic")
129 |
130 | static let midi = HTTPMediaType(type: .audio, subType: "x-midi")
| |- warning: static property 'midi' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'midi' 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 |
132 | static let mp3 = HTTPMediaType(type: .audio, subType: "mpeg")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:132:16: warning: static property 'mp3' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
130 | static let midi = HTTPMediaType(type: .audio, subType: "x-midi")
131 |
132 | static let mp3 = HTTPMediaType(type: .audio, subType: "mpeg")
| |- warning: static property 'mp3' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'mp3' 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 |
134 | static let wav = HTTPMediaType(type: .audio, subType: "wav")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:134:16: warning: static property 'wav' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
132 | static let mp3 = HTTPMediaType(type: .audio, subType: "mpeg")
133 |
134 | static let wav = HTTPMediaType(type: .audio, subType: "wav")
| |- warning: static property 'wav' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'wav' 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 |
136 | static let ogg = HTTPMediaType(type: .audio, subType: "vorbis")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:136:16: warning: static property 'ogg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
134 | static let wav = HTTPMediaType(type: .audio, subType: "wav")
135 |
136 | static let ogg = HTTPMediaType(type: .audio, subType: "vorbis")
| |- warning: static property 'ogg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'ogg' 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 |
138 | // image
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:140:16: warning: static property 'gif' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
138 | // image
139 |
140 | static let gif = HTTPMediaType(type: .image, subType: "gif")
| |- warning: static property 'gif' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'gif' 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 |
142 | static let jpeg = HTTPMediaType(type: .image, subType: "jpeg")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:142:16: warning: static property 'jpeg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
140 | static let gif = HTTPMediaType(type: .image, subType: "gif")
141 |
142 | static let jpeg = HTTPMediaType(type: .image, subType: "jpeg")
| |- warning: static property 'jpeg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'jpeg' 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 |
144 | static let png = HTTPMediaType(type: .image, subType: "png")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:144:16: warning: static property 'png' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
142 | static let jpeg = HTTPMediaType(type: .image, subType: "jpeg")
143 |
144 | static let png = HTTPMediaType(type: .image, subType: "png")
| |- warning: static property 'png' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'png' 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 |
146 | static let svg = HTTPMediaType(type: .image, subType: "svg+xml")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:146:16: warning: static property 'svg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
144 | static let png = HTTPMediaType(type: .image, subType: "png")
145 |
146 | static let svg = HTTPMediaType(type: .image, subType: "svg+xml")
| |- warning: static property 'svg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'svg' 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 |
148 | // message
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:152:16: warning: static property 'multipartFormData' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
150 | // multipart
151 |
152 | static let multipartFormData = HTTPMediaType(type: .multipart, subType: "form-data")
| |- warning: static property 'multipartFormData' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'multipartFormData' 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 |
154 | static func multipartFormData(boundary: String) -> HTTPMediaType {
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:162:16: warning: static property 'css' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
160 | // text
161 |
162 | static let css = HTTPMediaType(type: .text,
| |- warning: static property 'css' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'css' 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 | subType: "css",
164 | parameters: utf8CharsetParameter)
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:166:16: warning: static property 'html' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
164 | parameters: utf8CharsetParameter)
165 |
166 | static let html = HTTPMediaType(type: .text,
| |- warning: static property 'html' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'html' 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 | subType: "html",
168 | parameters: utf8CharsetParameter)
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:170:16: warning: static property 'plainText' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
168 | parameters: utf8CharsetParameter)
169 |
170 | static let plainText = HTTPMediaType(type: .text,
| |- warning: static property 'plainText' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'plainText' 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 | subType: "plain",
172 | parameters: utf8CharsetParameter)
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:176:16: warning: static property 'avi' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
174 | // video
175 |
176 | static let avi = HTTPMediaType(type: .video, subType: "avi")
| |- warning: static property 'avi' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'avi' 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 |
178 | static let mpeg = HTTPMediaType(type: .video, subType: "mpeg")
/host/spi-builder-workspace/Sources/APIota/HTTP/HTTPMediaType.swift:178:16: warning: static property 'mpeg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
5 | /// Also contains a number of default media types,
6 | /// defined according to: https://tools.ietf.org/html/rfc2045#section-5
7 | public struct HTTPMediaType {
| `- note: consider making struct 'HTTPMediaType' conform to the 'Sendable' protocol
8 |
9 | // MARK: - Enum definitions
:
176 | static let avi = HTTPMediaType(type: .video, subType: "avi")
177 |
178 | static let mpeg = HTTPMediaType(type: .video, subType: "mpeg")
| |- warning: static property 'mpeg' is not concurrency-safe because non-'Sendable' type 'HTTPMediaType' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'mpeg' 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 | }
180 |
[13/15] Compiling APIota APIotaClient.swift
[14/15] Compiling APIota APIotaCodableEndpoint.swift
[15/15] Compiling APIota HTTPStatusCode.swift
Build complete! (77.04s)
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"
}
Done.