Swift Package Index

Build Information

Failed to build ParseSwift, reference 4.14.2 (dc7666), with Swift 6.1 for Wasm on 28 May 2025 10:09:44 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4606859-2":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi 2>&1

Build Log

 964 |                           completion: @escaping (Result<([ResultType], Int), ParseError>) -> Void) {
 965 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:152:53: error: extra argument 'completion' in call
150 |         try await withCheckedThrowingContinuation { continuation in
151 |             self.withCount(options: options,
152 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
153 |         }
154 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1002:63: error: cannot find type 'DispatchQueue' in scope
1000 |     public func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
1001 |                                                options: API.Options = [],
1002 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1003 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1004 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:175:60: error: extra argument 'completion' in call
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
174 |                                   options: options,
175 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
176 |         }
177 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:173:18: error: generic parameter 'U' could not be inferred
168 |      [here](https://github.com/parse-community/parse-server/pull/7440).
169 |     */
170 |     func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
    |          `- note: in call to function 'withCountExplain(usingMongoDB:options:)'
171 |                                         options: API.Options = []) async throws -> [U] {
172 |         try await withCheckedThrowingContinuation { continuation in
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
    |                  `- error: generic parameter 'U' could not be inferred
174 |                                   options: options,
175 |                                   completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1095:42: error: cannot find type 'DispatchQueue' in scope
1093 |     public func aggregate(_ pipeline: [[String: Encodable]],
1094 |                           options: API.Options = [],
1095 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
1096 |                           completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1097 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:194:53: error: extra argument 'completion' in call
192 |             self.aggregate(pipeline,
193 |                            options: options,
194 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
195 |         }
196 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1220:63: error: cannot find type 'DispatchQueue' in scope
1218 |                                                usingMongoDB: Bool = false,
1219 |                                                options: API.Options = [],
1220 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1221 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1222 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:223:60: error: extra argument 'completion' in call
221 |                                   usingMongoDB: usingMongoDB,
222 |                                   options: options,
223 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
224 |         }
225 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1319:41: error: cannot find type 'DispatchQueue' in scope
1317 |     public func distinct(_ key: String,
1318 |                          options: API.Options = [],
1319 |                          callbackQueue: DispatchQueue = .main,
     |                                         `- error: cannot find type 'DispatchQueue' in scope
1320 |                          completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1321 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:240:18: error: cannot call value of non-function type 'String?'
238 |                   options: API.Options = []) async throws -> [ResultType] {
239 |         try await withCheckedThrowingContinuation { continuation in
240 |             self.distinct(key,
    |                  `- error: cannot call value of non-function type 'String?'
241 |                           options: options,
242 |                           completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1402:62: error: cannot find type 'DispatchQueue' in scope
1400 |                                               usingMongoDB: Bool = false,
1401 |                                               options: API.Options = [],
1402 |                                               callbackQueue: DispatchQueue = .main,
     |                                                              `- error: cannot find type 'DispatchQueue' in scope
1403 |                                               completion: @escaping (Result<[U], ParseError>) -> Void) {
1404 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:271:59: error: extra argument 'completion' in call
269 |                                  usingMongoDB: usingMongoDB,
270 |                                  options: options,
271 |                                  completion: continuation.resume)
    |                                                           `- error: extra argument 'completion' in call
272 |         }
273 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:48:26: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  46 |     }
  47 |
  48 |     struct AggregateBody<T>: Codable where T: ParseObject {
     |                          `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  49 |         let pipeline: [[String: AnyCodable]]?
  50 |         let hint: AnyCodable?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:79:25: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  77 |     }
  78 |
  79 |     struct DistinctBody<T>: Codable where T: ParseObject {
     |                         `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  80 |         let hint: AnyCodable?
  81 |         let explain: Bool?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:589:21: error: generic parameter 'U' could not be inferred
 587 |         if !usingMongoDB {
 588 |             do {
 589 |                 try findExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 590 |                                                       callbackQueue: callbackQueue) { result in
 591 |                     completion(result)
     :
1559 |     }
1560 |
1561 |     func findExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainCommand()'
1562 |         var query = self
1563 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:602:21: error: generic parameter 'U' could not be inferred
 600 |         } else {
 601 |             do {
 602 |                 try findExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 603 |                                                            callbackQueue: callbackQueue) { result in
 604 |                     completion(result)
     :
1687 |     }
1688 |
1689 |     func findExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainMongoCommand()'
1690 |         var query = self
1691 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:646:21: error: cannot find 'DispatchQueue' in scope
 644 |         }
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
     |                     `- error: cannot find 'DispatchQueue' in scope
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:647:41: error: cannot infer contextual base in reference to member 'default'
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
     |                                         `- error: cannot infer contextual base in reference to member 'default'
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:648:48: error: cannot infer contextual base in reference to member 'concurrent'
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
     |                                                `- error: cannot infer contextual base in reference to member 'concurrent'
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:649:58: error: cannot infer contextual base in reference to member 'inherit'
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
     |                                                          `- error: cannot infer contextual base in reference to member 'inherit'
 650 |                                   target: nil)
 651 |         queue.sync {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:650:43: error: 'nil' requires a contextual type
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
     |                                           `- error: 'nil' requires a contextual type
 651 |         queue.sync {
 652 |
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:800:21: error: generic parameter 'U' could not be inferred
 798 |         if !usingMongoDB {
 799 |             do {
 800 |                 try firstExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 801 |                                                        callbackQueue: callbackQueue) { result in
 802 |                     completion(result)
     :
1577 |     }
1578 |
1579 |     func firstExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainCommand()'
1580 |         var query = self
1581 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:813:21: error: generic parameter 'U' could not be inferred
 811 |         } else {
 812 |             do {
 813 |                 try firstExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 814 |                                                             callbackQueue: callbackQueue) { result in
 815 |                     completion(result)
     :
1705 |     }
1706 |
1707 |     func firstExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainMongoCommand()'
1708 |         var query = self
1709 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:926:21: error: generic parameter 'U' could not be inferred
 924 |         if !usingMongoDB {
 925 |             do {
 926 |                 try countExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 927 |                                                        callbackQueue: callbackQueue) { result in
 928 |                     completion(result)
     :
1610 |     }
1611 |
1612 |     func countExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainCommand()'
1613 |         var query = self
1614 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:939:21: error: generic parameter 'U' could not be inferred
 937 |         } else {
 938 |             do {
 939 |                 try countExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 940 |                                                             callbackQueue: callbackQueue) { result in
 941 |                     completion(result)
     :
1734 |     }
1735 |
1736 |     func countExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainMongoCommand()'
1737 |         var query = self
1738 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1012:21: error: generic parameter 'U' could not be inferred
1010 |         if !usingMongoDB {
1011 |             do {
1012 |                 try withCountExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1013 |                                                            callbackQueue: callbackQueue) { result in
1014 |                     completion(result)
     :
1630 |     }
1631 |
1632 |     func withCountExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainCommand()'
1633 |         var query = self
1634 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1025:21: error: generic parameter 'U' could not be inferred
1023 |         } else {
1024 |             do {
1025 |                 try withCountExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1026 |                                                             callbackQueue: callbackQueue) { result in
1027 |                     completion(result)
     :
1754 |     }
1755 |
1756 |     func withCountExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainMongoCommand()'
1757 |         var query = self
1758 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1256:27: error: generic parameter 'U' could not be inferred
1254 |         if !usingMongoDB {
1255 |             do {
1256 |                 try query.aggregateExplainCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1257 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1258 |                         completion(result)
     :
1649 |     }
1650 |
1651 |     func aggregateExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainCommand()'
1652 |         var query = self
1653 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1269:27: error: generic parameter 'U' could not be inferred
1267 |         } else {
1268 |             do {
1269 |                 try query.aggregateExplainMongoCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1270 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1271 |                         completion(result)
     :
1774 |
1775 |     // swiftlint:disable:next line_length
1776 |     func aggregateExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainMongoCommand()'
1777 |         var query = self
1778 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1414:21: error: generic parameter 'U' could not be inferred
1412 |         if !usingMongoDB {
1413 |             do {
1414 |                 try distinctExplainCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1415 |                     .executeAsync(options: options,
1416 |                                   callbackQueue: callbackQueue) { result in
     :
1669 |
1670 |     // swiftlint:disable:next line_length
1671 |     func distinctExplainCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainCommand(key:)'
1672 |         var query = self
1673 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1428:21: error: generic parameter 'U' could not be inferred
1426 |         } else {
1427 |             do {
1428 |                 try distinctExplainMongoCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1429 |                     .executeAsync(options: options,
1430 |                                   callbackQueue: callbackQueue) { result in
     :
1794 |
1795 |     // swiftlint:disable:next line_length
1796 |     func distinctExplainMongoCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainMongoCommand(key:)'
1797 |         var query = self
1798 |         query.explain = true
[181/184] Compiling ParseSwift Query.swift
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:174:37: error: cannot find type 'DispatchQueue' in scope
172 |     */
173 |     public func send(options: API.Options = [],
174 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
175 |                      completion: @escaping (Result<String, ParseError>) -> Void) {
176 |         if expirationTime != nil && expirationInterval != nil {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:238:37: error: cannot find type 'DispatchQueue' in scope
236 |     func fetchStatus(_ statusId: String,
237 |                      options: API.Options = [],
238 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
239 |                      completion: @escaping (Result<ParsePushStatus<V>, ParseError>) -> Void) {
240 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/API/API.swift:166:26: error: cannot find type 'URLRequest' in scope
164 |         /// [documentation](https://developer.apple.com/documentation/foundation/url_loading_system/accessing_cached_data)
165 |         /// for more info.
166 |         case cachePolicy(URLRequest.CachePolicy)
    |                          `- error: cannot find type 'URLRequest' in scope
167 |
168 |         public func hash(into hasher: inout Hasher) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:190:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
188 |         var options = options
189 |         options.insert(.useMasterKey)
190 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
191 |         sendCommand()
192 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand.swift:61:42: error: cannot find type 'DispatchQueue' in scope
 59 |         // MARK: Asynchronous Execution
 60 |         func executeAsync(options: API.Options,
 61 |                           callbackQueue: DispatchQueue,
    |                                          `- error: cannot find type 'DispatchQueue' in scope
 62 |                           completion: @escaping(Result<U, ParseError>) -> Void) {
 63 |
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand+async.swift:18:38: error: cannot find type 'DispatchQueue' in scope
16 |     // MARK: Asynchronous Execution
17 |     func executeAsync(options: API.Options,
18 |                       callbackQueue: DispatchQueue) async throws -> U {
   |                                      `- error: cannot find type 'DispatchQueue' in scope
19 |         try await withCheckedThrowingContinuation { continuation in
20 |             self.executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:242:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
240 |         var options = options
241 |         options.insert(.useMasterKey)
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:18:53: error: cannot find type 'DispatchQueue' in scope
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:745:38: error: cannot find type 'DispatchQueue' in scope
 743 |     */
 744 |     public func first(options: API.Options = [],
 745 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 746 |                       completion: @escaping (Result<ResultType, ParseError>) -> Void) {
 747 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:82:31: error: cannot find type 'DispatchQueue' in scope
80 |       `error` will be `nil` if `result` is set OR if the query succeeded, but found no results.
81 |     */
82 |     func first(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<ResultType, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
83 |         first(options: [], callbackQueue: callbackQueue, completion: completion)
84 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:244:51: error: extra argument 'completion' in call
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
    |                                                   `- error: extra argument 'completion' in call
245 |     }
246 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:263:38: error: cannot find type 'DispatchQueue' in scope
261 |     */
262 |     public func fetch(options: API.Options = [],
263 |                       callbackQueue: DispatchQueue = .main,
    |                                      `- error: cannot find type 'DispatchQueue' in scope
264 |                       completion: @escaping (Result<Self, ParseError>) -> Void) {
265 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:27:49: error: extra argument 'completion' in call
 25 |         try await withCheckedThrowingContinuation { continuation in
 26 |             self.fetch(options: options,
 27 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 28 |         }
 29 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:300:39: error: cannot find type 'DispatchQueue' in scope
298 |     */
299 |     public func create(options: API.Options = [],
300 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
301 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
302 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:45:50: error: extra argument 'completion' in call
 43 |         try await withCheckedThrowingContinuation { continuation in
 44 |             self.create(options: options,
 45 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 46 |         }
 47 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:325:39: error: cannot find type 'DispatchQueue' in scope
323 |     */
324 |     public func update(options: API.Options = [],
325 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
326 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
327 |         var mutableSchema = self
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:63:50: error: extra argument 'completion' in call
 61 |         try await withCheckedThrowingContinuation { continuation in
 62 |             self.update(options: options,
 63 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 64 |         }
 65 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:379:24: error: cannot find type 'DispatchQueue' in scope
377 |     public func purge(
378 |         options: API.Options = [],
379 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
380 |         completion: @escaping (Result<Void, ParseError>) -> Void
381 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:82:50: error: extra argument 'completion' in call
 80 |         let result = try await withCheckedThrowingContinuation { continuation in
 81 |             self.purge(options: options,
 82 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 83 |         }
 84 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:417:24: error: cannot find type 'DispatchQueue' in scope
415 |     public func delete(
416 |         options: API.Options = [],
417 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
418 |         completion: @escaping (Result<Void, ParseError>) -> Void
419 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:105:50: error: extra argument 'completion' in call
103 |         let result = try await withCheckedThrowingContinuation { continuation in
104 |             self.delete(options: options,
105 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
106 |         }
107 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:267:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
265 |         var options = options
266 |         options.insert(.useMasterKey)
267 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
268 |         fetchCommand()
269 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:304:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
302 |         var options = options
303 |         options.insert(.useMasterKey)
304 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
305 |         createCommand()
306 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:335:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
333 |         var options = options
334 |         options.insert(.useMasterKey)
335 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
336 |         mutableSchema.updateCommand()
337 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:384:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
382 |         var options = options
383 |         options.insert(.useMasterKey)
384 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
385 |         purgeCommand().executeAsync(options: options,
386 |                                         callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:422:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
420 |         var options = options
421 |         options.insert(.useMasterKey)
422 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
423 |         deleteCommand().executeAsync(options: options,
424 |                                          callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:135:31: error: cannot find type 'DispatchQueue' in scope
133 |     func fetch(includeKeys: [String]? = nil,
134 |                options: API.Options = [],
135 |                callbackQueue: DispatchQueue = .main,
    |                               `- error: cannot find type 'DispatchQueue' in scope
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer+async.swift:29:49: error: extra argument 'completion' in call
27 |             self.fetch(includeKeys: includeKeys,
28 |                        options: options,
29 |                        completion: continuation.resume)
   |                                                 `- error: extra argument 'completion' in call
30 |         }
31 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:113:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
111 |                options: API.Options = []) throws -> T {
112 |         var options = options
113 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
114 |         let path = API.Endpoint.object(className: className, objectId: objectId)
115 |         return try API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:138:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
138 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
139 |         let path = API.Endpoint.object(className: className, objectId: objectId)
140 |         API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:16:52: error: cannot find type 'DispatchQueue' in scope
14 |     func first(options: API.Options) throws -> ResultType
15 |     func count(options: API.Options) throws -> Int
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
   |                                                    `- error: cannot find type 'DispatchQueue' in scope
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:540:37: error: cannot find type 'DispatchQueue' in scope
 538 |     */
 539 |     public func find(options: API.Options = [],
 540 |                      callbackQueue: DispatchQueue = .main,
     |                                     `- error: cannot find type 'DispatchQueue' in scope
 541 |                      completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 542 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:67:30: error: cannot find type 'DispatchQueue' in scope
65 |       It should have the following argument signature: `(Result<[ResultType], ParseError>)`
66 |     */
67 |     func find(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
   |                              `- error: cannot find type 'DispatchQueue' in scope
68 |         find(options: [], callbackQueue: callbackQueue, completion: completion)
69 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:25:48: error: extra argument 'completion' in call
 23 |         try await withCheckedThrowingContinuation { continuation in
 24 |             self.find(options: options,
 25 |                       completion: continuation.resume)
    |                                                `- error: extra argument 'completion' in call
 26 |         }
 27 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:579:58: error: cannot find type 'DispatchQueue' in scope
 577 |     public func findExplain<U: Decodable>(usingMongoDB: Bool = false,
 578 |                                           options: API.Options = [],
 579 |                                           callbackQueue: DispatchQueue = .main,
     |                                                          `- error: cannot find type 'DispatchQueue' in scope
 580 |                                           completion: @escaping (Result<[U], ParseError>) -> Void) {
 581 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:48:55: error: extra argument 'completion' in call
 46 |             self.findExplain(usingMongoDB: usingMongoDB,
 47 |                              options: options,
 48 |                              completion: continuation.resume)
    |                                                       `- error: extra argument 'completion' in call
 49 |         }
 50 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:631:40: error: cannot find type 'DispatchQueue' in scope
 629 |     public func findAll(batchLimit limit: Int? = nil,
 630 |                         options: API.Options = [],
 631 |                         callbackQueue: DispatchQueue = .main,
     |                                        `- error: cannot find type 'DispatchQueue' in scope
 632 |                         completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 633 |         if self.limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:66:51: error: extra argument 'completion' in call
 64 |             self.findAll(batchLimit: batchLimit,
 65 |                          options: options,
 66 |                          completion: continuation.resume)
    |                                                   `- error: extra argument 'completion' in call
 67 |         }
 68 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:79:49: error: extra argument 'completion' in call
 77 |         try await withCheckedThrowingContinuation { continuation in
 78 |             self.first(options: options,
 79 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 80 |         }
 81 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:788:59: error: cannot find type 'DispatchQueue' in scope
 786 |     public func firstExplain<U: Decodable>(usingMongoDB: Bool = false,
 787 |                                            options: API.Options = [],
 788 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 789 |                                            completion: @escaping (Result<U, ParseError>) -> Void) {
 790 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:102:56: error: extra argument 'completion' in call
100 |             self.firstExplain(usingMongoDB: usingMongoDB,
101 |                               options: options,
102 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
103 |         }
104 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:20:53: error: cannot find type 'DispatchQueue' in scope
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
21 |                completion: @escaping (Result<Int, ParseError>) -> Void)
22 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:877:38: error: cannot find type 'DispatchQueue' in scope
 875 |     */
 876 |     public func count(options: API.Options = [],
 877 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 878 |                       completion: @escaping (Result<Int, ParseError>) -> Void) {
 879 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:93:31: error: cannot find type 'DispatchQueue' in scope
91 |       It should have the following argument signature: `^(int count, ParseError *error)`
92 |     */
93 |     func count(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<Int, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
94 |         count(options: [], callbackQueue: callbackQueue, completion: completion)
95 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:115:49: error: extra argument 'completion' in call
113 |         try await withCheckedThrowingContinuation { continuation in
114 |             self.count(options: options,
115 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
116 |         }
117 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:916:59: error: cannot find type 'DispatchQueue' in scope
 914 |     public func countExplain<U: Decodable>(usingMongoDB: Bool = false,
 915 |                                            options: API.Options = [],
 916 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 917 |                                            completion: @escaping (Result<[U], ParseError>) -> Void) {
 918 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:138:56: error: extra argument 'completion' in call
136 |             self.countExplain(usingMongoDB: usingMongoDB,
137 |                               options: options,
138 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
139 |         }
140 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:963:42: error: cannot find type 'DispatchQueue' in scope
 961 |     */
 962 |     public func withCount(options: API.Options = [],
 963 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
 964 |                           completion: @escaping (Result<([ResultType], Int), ParseError>) -> Void) {
 965 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:152:53: error: extra argument 'completion' in call
150 |         try await withCheckedThrowingContinuation { continuation in
151 |             self.withCount(options: options,
152 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
153 |         }
154 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1002:63: error: cannot find type 'DispatchQueue' in scope
1000 |     public func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
1001 |                                                options: API.Options = [],
1002 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1003 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1004 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:175:60: error: extra argument 'completion' in call
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
174 |                                   options: options,
175 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
176 |         }
177 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:173:18: error: generic parameter 'U' could not be inferred
168 |      [here](https://github.com/parse-community/parse-server/pull/7440).
169 |     */
170 |     func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
    |          `- note: in call to function 'withCountExplain(usingMongoDB:options:)'
171 |                                         options: API.Options = []) async throws -> [U] {
172 |         try await withCheckedThrowingContinuation { continuation in
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
    |                  `- error: generic parameter 'U' could not be inferred
174 |                                   options: options,
175 |                                   completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1095:42: error: cannot find type 'DispatchQueue' in scope
1093 |     public func aggregate(_ pipeline: [[String: Encodable]],
1094 |                           options: API.Options = [],
1095 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
1096 |                           completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1097 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:194:53: error: extra argument 'completion' in call
192 |             self.aggregate(pipeline,
193 |                            options: options,
194 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
195 |         }
196 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1220:63: error: cannot find type 'DispatchQueue' in scope
1218 |                                                usingMongoDB: Bool = false,
1219 |                                                options: API.Options = [],
1220 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1221 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1222 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:223:60: error: extra argument 'completion' in call
221 |                                   usingMongoDB: usingMongoDB,
222 |                                   options: options,
223 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
224 |         }
225 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1319:41: error: cannot find type 'DispatchQueue' in scope
1317 |     public func distinct(_ key: String,
1318 |                          options: API.Options = [],
1319 |                          callbackQueue: DispatchQueue = .main,
     |                                         `- error: cannot find type 'DispatchQueue' in scope
1320 |                          completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1321 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:240:18: error: cannot call value of non-function type 'String?'
238 |                   options: API.Options = []) async throws -> [ResultType] {
239 |         try await withCheckedThrowingContinuation { continuation in
240 |             self.distinct(key,
    |                  `- error: cannot call value of non-function type 'String?'
241 |                           options: options,
242 |                           completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1402:62: error: cannot find type 'DispatchQueue' in scope
1400 |                                               usingMongoDB: Bool = false,
1401 |                                               options: API.Options = [],
1402 |                                               callbackQueue: DispatchQueue = .main,
     |                                                              `- error: cannot find type 'DispatchQueue' in scope
1403 |                                               completion: @escaping (Result<[U], ParseError>) -> Void) {
1404 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:271:59: error: extra argument 'completion' in call
269 |                                  usingMongoDB: usingMongoDB,
270 |                                  options: options,
271 |                                  completion: continuation.resume)
    |                                                           `- error: extra argument 'completion' in call
272 |         }
273 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:48:26: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  46 |     }
  47 |
  48 |     struct AggregateBody<T>: Codable where T: ParseObject {
     |                          `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  49 |         let pipeline: [[String: AnyCodable]]?
  50 |         let hint: AnyCodable?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:79:25: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  77 |     }
  78 |
  79 |     struct DistinctBody<T>: Codable where T: ParseObject {
     |                         `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  80 |         let hint: AnyCodable?
  81 |         let explain: Bool?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:589:21: error: generic parameter 'U' could not be inferred
 587 |         if !usingMongoDB {
 588 |             do {
 589 |                 try findExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 590 |                                                       callbackQueue: callbackQueue) { result in
 591 |                     completion(result)
     :
1559 |     }
1560 |
1561 |     func findExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainCommand()'
1562 |         var query = self
1563 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:602:21: error: generic parameter 'U' could not be inferred
 600 |         } else {
 601 |             do {
 602 |                 try findExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 603 |                                                            callbackQueue: callbackQueue) { result in
 604 |                     completion(result)
     :
1687 |     }
1688 |
1689 |     func findExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainMongoCommand()'
1690 |         var query = self
1691 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:646:21: error: cannot find 'DispatchQueue' in scope
 644 |         }
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
     |                     `- error: cannot find 'DispatchQueue' in scope
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:647:41: error: cannot infer contextual base in reference to member 'default'
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
     |                                         `- error: cannot infer contextual base in reference to member 'default'
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:648:48: error: cannot infer contextual base in reference to member 'concurrent'
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
     |                                                `- error: cannot infer contextual base in reference to member 'concurrent'
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:649:58: error: cannot infer contextual base in reference to member 'inherit'
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
     |                                                          `- error: cannot infer contextual base in reference to member 'inherit'
 650 |                                   target: nil)
 651 |         queue.sync {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:650:43: error: 'nil' requires a contextual type
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
     |                                           `- error: 'nil' requires a contextual type
 651 |         queue.sync {
 652 |
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:800:21: error: generic parameter 'U' could not be inferred
 798 |         if !usingMongoDB {
 799 |             do {
 800 |                 try firstExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 801 |                                                        callbackQueue: callbackQueue) { result in
 802 |                     completion(result)
     :
1577 |     }
1578 |
1579 |     func firstExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainCommand()'
1580 |         var query = self
1581 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:813:21: error: generic parameter 'U' could not be inferred
 811 |         } else {
 812 |             do {
 813 |                 try firstExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 814 |                                                             callbackQueue: callbackQueue) { result in
 815 |                     completion(result)
     :
1705 |     }
1706 |
1707 |     func firstExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainMongoCommand()'
1708 |         var query = self
1709 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:926:21: error: generic parameter 'U' could not be inferred
 924 |         if !usingMongoDB {
 925 |             do {
 926 |                 try countExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 927 |                                                        callbackQueue: callbackQueue) { result in
 928 |                     completion(result)
     :
1610 |     }
1611 |
1612 |     func countExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainCommand()'
1613 |         var query = self
1614 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:939:21: error: generic parameter 'U' could not be inferred
 937 |         } else {
 938 |             do {
 939 |                 try countExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 940 |                                                             callbackQueue: callbackQueue) { result in
 941 |                     completion(result)
     :
1734 |     }
1735 |
1736 |     func countExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainMongoCommand()'
1737 |         var query = self
1738 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1012:21: error: generic parameter 'U' could not be inferred
1010 |         if !usingMongoDB {
1011 |             do {
1012 |                 try withCountExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1013 |                                                            callbackQueue: callbackQueue) { result in
1014 |                     completion(result)
     :
1630 |     }
1631 |
1632 |     func withCountExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainCommand()'
1633 |         var query = self
1634 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1025:21: error: generic parameter 'U' could not be inferred
1023 |         } else {
1024 |             do {
1025 |                 try withCountExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1026 |                                                             callbackQueue: callbackQueue) { result in
1027 |                     completion(result)
     :
1754 |     }
1755 |
1756 |     func withCountExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainMongoCommand()'
1757 |         var query = self
1758 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1256:27: error: generic parameter 'U' could not be inferred
1254 |         if !usingMongoDB {
1255 |             do {
1256 |                 try query.aggregateExplainCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1257 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1258 |                         completion(result)
     :
1649 |     }
1650 |
1651 |     func aggregateExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainCommand()'
1652 |         var query = self
1653 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1269:27: error: generic parameter 'U' could not be inferred
1267 |         } else {
1268 |             do {
1269 |                 try query.aggregateExplainMongoCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1270 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1271 |                         completion(result)
     :
1774 |
1775 |     // swiftlint:disable:next line_length
1776 |     func aggregateExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainMongoCommand()'
1777 |         var query = self
1778 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1414:21: error: generic parameter 'U' could not be inferred
1412 |         if !usingMongoDB {
1413 |             do {
1414 |                 try distinctExplainCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1415 |                     .executeAsync(options: options,
1416 |                                   callbackQueue: callbackQueue) { result in
     :
1669 |
1670 |     // swiftlint:disable:next line_length
1671 |     func distinctExplainCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainCommand(key:)'
1672 |         var query = self
1673 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1428:21: error: generic parameter 'U' could not be inferred
1426 |         } else {
1427 |             do {
1428 |                 try distinctExplainMongoCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1429 |                     .executeAsync(options: options,
1430 |                                   callbackQueue: callbackQueue) { result in
     :
1794 |
1795 |     // swiftlint:disable:next line_length
1796 |     func distinctExplainMongoCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainMongoCommand(key:)'
1797 |         var query = self
1798 |         query.explain = true
[182/184] Compiling ParseSwift QueryConstraint.swift
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:174:37: error: cannot find type 'DispatchQueue' in scope
172 |     */
173 |     public func send(options: API.Options = [],
174 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
175 |                      completion: @escaping (Result<String, ParseError>) -> Void) {
176 |         if expirationTime != nil && expirationInterval != nil {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:238:37: error: cannot find type 'DispatchQueue' in scope
236 |     func fetchStatus(_ statusId: String,
237 |                      options: API.Options = [],
238 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
239 |                      completion: @escaping (Result<ParsePushStatus<V>, ParseError>) -> Void) {
240 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/API/API.swift:166:26: error: cannot find type 'URLRequest' in scope
164 |         /// [documentation](https://developer.apple.com/documentation/foundation/url_loading_system/accessing_cached_data)
165 |         /// for more info.
166 |         case cachePolicy(URLRequest.CachePolicy)
    |                          `- error: cannot find type 'URLRequest' in scope
167 |
168 |         public func hash(into hasher: inout Hasher) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:190:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
188 |         var options = options
189 |         options.insert(.useMasterKey)
190 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
191 |         sendCommand()
192 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand.swift:61:42: error: cannot find type 'DispatchQueue' in scope
 59 |         // MARK: Asynchronous Execution
 60 |         func executeAsync(options: API.Options,
 61 |                           callbackQueue: DispatchQueue,
    |                                          `- error: cannot find type 'DispatchQueue' in scope
 62 |                           completion: @escaping(Result<U, ParseError>) -> Void) {
 63 |
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand+async.swift:18:38: error: cannot find type 'DispatchQueue' in scope
16 |     // MARK: Asynchronous Execution
17 |     func executeAsync(options: API.Options,
18 |                       callbackQueue: DispatchQueue) async throws -> U {
   |                                      `- error: cannot find type 'DispatchQueue' in scope
19 |         try await withCheckedThrowingContinuation { continuation in
20 |             self.executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:242:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
240 |         var options = options
241 |         options.insert(.useMasterKey)
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:18:53: error: cannot find type 'DispatchQueue' in scope
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:745:38: error: cannot find type 'DispatchQueue' in scope
 743 |     */
 744 |     public func first(options: API.Options = [],
 745 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 746 |                       completion: @escaping (Result<ResultType, ParseError>) -> Void) {
 747 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:82:31: error: cannot find type 'DispatchQueue' in scope
80 |       `error` will be `nil` if `result` is set OR if the query succeeded, but found no results.
81 |     */
82 |     func first(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<ResultType, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
83 |         first(options: [], callbackQueue: callbackQueue, completion: completion)
84 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:244:51: error: extra argument 'completion' in call
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
    |                                                   `- error: extra argument 'completion' in call
245 |     }
246 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:263:38: error: cannot find type 'DispatchQueue' in scope
261 |     */
262 |     public func fetch(options: API.Options = [],
263 |                       callbackQueue: DispatchQueue = .main,
    |                                      `- error: cannot find type 'DispatchQueue' in scope
264 |                       completion: @escaping (Result<Self, ParseError>) -> Void) {
265 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:27:49: error: extra argument 'completion' in call
 25 |         try await withCheckedThrowingContinuation { continuation in
 26 |             self.fetch(options: options,
 27 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 28 |         }
 29 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:300:39: error: cannot find type 'DispatchQueue' in scope
298 |     */
299 |     public func create(options: API.Options = [],
300 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
301 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
302 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:45:50: error: extra argument 'completion' in call
 43 |         try await withCheckedThrowingContinuation { continuation in
 44 |             self.create(options: options,
 45 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 46 |         }
 47 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:325:39: error: cannot find type 'DispatchQueue' in scope
323 |     */
324 |     public func update(options: API.Options = [],
325 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
326 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
327 |         var mutableSchema = self
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:63:50: error: extra argument 'completion' in call
 61 |         try await withCheckedThrowingContinuation { continuation in
 62 |             self.update(options: options,
 63 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 64 |         }
 65 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:379:24: error: cannot find type 'DispatchQueue' in scope
377 |     public func purge(
378 |         options: API.Options = [],
379 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
380 |         completion: @escaping (Result<Void, ParseError>) -> Void
381 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:82:50: error: extra argument 'completion' in call
 80 |         let result = try await withCheckedThrowingContinuation { continuation in
 81 |             self.purge(options: options,
 82 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 83 |         }
 84 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:417:24: error: cannot find type 'DispatchQueue' in scope
415 |     public func delete(
416 |         options: API.Options = [],
417 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
418 |         completion: @escaping (Result<Void, ParseError>) -> Void
419 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:105:50: error: extra argument 'completion' in call
103 |         let result = try await withCheckedThrowingContinuation { continuation in
104 |             self.delete(options: options,
105 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
106 |         }
107 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:267:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
265 |         var options = options
266 |         options.insert(.useMasterKey)
267 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
268 |         fetchCommand()
269 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:304:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
302 |         var options = options
303 |         options.insert(.useMasterKey)
304 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
305 |         createCommand()
306 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:335:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
333 |         var options = options
334 |         options.insert(.useMasterKey)
335 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
336 |         mutableSchema.updateCommand()
337 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:384:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
382 |         var options = options
383 |         options.insert(.useMasterKey)
384 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
385 |         purgeCommand().executeAsync(options: options,
386 |                                         callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:422:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
420 |         var options = options
421 |         options.insert(.useMasterKey)
422 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
423 |         deleteCommand().executeAsync(options: options,
424 |                                          callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:135:31: error: cannot find type 'DispatchQueue' in scope
133 |     func fetch(includeKeys: [String]? = nil,
134 |                options: API.Options = [],
135 |                callbackQueue: DispatchQueue = .main,
    |                               `- error: cannot find type 'DispatchQueue' in scope
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer+async.swift:29:49: error: extra argument 'completion' in call
27 |             self.fetch(includeKeys: includeKeys,
28 |                        options: options,
29 |                        completion: continuation.resume)
   |                                                 `- error: extra argument 'completion' in call
30 |         }
31 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:113:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
111 |                options: API.Options = []) throws -> T {
112 |         var options = options
113 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
114 |         let path = API.Endpoint.object(className: className, objectId: objectId)
115 |         return try API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:138:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
138 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
139 |         let path = API.Endpoint.object(className: className, objectId: objectId)
140 |         API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:16:52: error: cannot find type 'DispatchQueue' in scope
14 |     func first(options: API.Options) throws -> ResultType
15 |     func count(options: API.Options) throws -> Int
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
   |                                                    `- error: cannot find type 'DispatchQueue' in scope
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:540:37: error: cannot find type 'DispatchQueue' in scope
 538 |     */
 539 |     public func find(options: API.Options = [],
 540 |                      callbackQueue: DispatchQueue = .main,
     |                                     `- error: cannot find type 'DispatchQueue' in scope
 541 |                      completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 542 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:67:30: error: cannot find type 'DispatchQueue' in scope
65 |       It should have the following argument signature: `(Result<[ResultType], ParseError>)`
66 |     */
67 |     func find(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
   |                              `- error: cannot find type 'DispatchQueue' in scope
68 |         find(options: [], callbackQueue: callbackQueue, completion: completion)
69 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:25:48: error: extra argument 'completion' in call
 23 |         try await withCheckedThrowingContinuation { continuation in
 24 |             self.find(options: options,
 25 |                       completion: continuation.resume)
    |                                                `- error: extra argument 'completion' in call
 26 |         }
 27 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:579:58: error: cannot find type 'DispatchQueue' in scope
 577 |     public func findExplain<U: Decodable>(usingMongoDB: Bool = false,
 578 |                                           options: API.Options = [],
 579 |                                           callbackQueue: DispatchQueue = .main,
     |                                                          `- error: cannot find type 'DispatchQueue' in scope
 580 |                                           completion: @escaping (Result<[U], ParseError>) -> Void) {
 581 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:48:55: error: extra argument 'completion' in call
 46 |             self.findExplain(usingMongoDB: usingMongoDB,
 47 |                              options: options,
 48 |                              completion: continuation.resume)
    |                                                       `- error: extra argument 'completion' in call
 49 |         }
 50 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:631:40: error: cannot find type 'DispatchQueue' in scope
 629 |     public func findAll(batchLimit limit: Int? = nil,
 630 |                         options: API.Options = [],
 631 |                         callbackQueue: DispatchQueue = .main,
     |                                        `- error: cannot find type 'DispatchQueue' in scope
 632 |                         completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 633 |         if self.limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:66:51: error: extra argument 'completion' in call
 64 |             self.findAll(batchLimit: batchLimit,
 65 |                          options: options,
 66 |                          completion: continuation.resume)
    |                                                   `- error: extra argument 'completion' in call
 67 |         }
 68 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:79:49: error: extra argument 'completion' in call
 77 |         try await withCheckedThrowingContinuation { continuation in
 78 |             self.first(options: options,
 79 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 80 |         }
 81 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:788:59: error: cannot find type 'DispatchQueue' in scope
 786 |     public func firstExplain<U: Decodable>(usingMongoDB: Bool = false,
 787 |                                            options: API.Options = [],
 788 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 789 |                                            completion: @escaping (Result<U, ParseError>) -> Void) {
 790 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:102:56: error: extra argument 'completion' in call
100 |             self.firstExplain(usingMongoDB: usingMongoDB,
101 |                               options: options,
102 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
103 |         }
104 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:20:53: error: cannot find type 'DispatchQueue' in scope
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
21 |                completion: @escaping (Result<Int, ParseError>) -> Void)
22 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:877:38: error: cannot find type 'DispatchQueue' in scope
 875 |     */
 876 |     public func count(options: API.Options = [],
 877 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 878 |                       completion: @escaping (Result<Int, ParseError>) -> Void) {
 879 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:93:31: error: cannot find type 'DispatchQueue' in scope
91 |       It should have the following argument signature: `^(int count, ParseError *error)`
92 |     */
93 |     func count(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<Int, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
94 |         count(options: [], callbackQueue: callbackQueue, completion: completion)
95 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:115:49: error: extra argument 'completion' in call
113 |         try await withCheckedThrowingContinuation { continuation in
114 |             self.count(options: options,
115 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
116 |         }
117 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:916:59: error: cannot find type 'DispatchQueue' in scope
 914 |     public func countExplain<U: Decodable>(usingMongoDB: Bool = false,
 915 |                                            options: API.Options = [],
 916 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 917 |                                            completion: @escaping (Result<[U], ParseError>) -> Void) {
 918 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:138:56: error: extra argument 'completion' in call
136 |             self.countExplain(usingMongoDB: usingMongoDB,
137 |                               options: options,
138 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
139 |         }
140 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:963:42: error: cannot find type 'DispatchQueue' in scope
 961 |     */
 962 |     public func withCount(options: API.Options = [],
 963 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
 964 |                           completion: @escaping (Result<([ResultType], Int), ParseError>) -> Void) {
 965 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:152:53: error: extra argument 'completion' in call
150 |         try await withCheckedThrowingContinuation { continuation in
151 |             self.withCount(options: options,
152 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
153 |         }
154 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1002:63: error: cannot find type 'DispatchQueue' in scope
1000 |     public func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
1001 |                                                options: API.Options = [],
1002 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1003 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1004 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:175:60: error: extra argument 'completion' in call
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
174 |                                   options: options,
175 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
176 |         }
177 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:173:18: error: generic parameter 'U' could not be inferred
168 |      [here](https://github.com/parse-community/parse-server/pull/7440).
169 |     */
170 |     func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
    |          `- note: in call to function 'withCountExplain(usingMongoDB:options:)'
171 |                                         options: API.Options = []) async throws -> [U] {
172 |         try await withCheckedThrowingContinuation { continuation in
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
    |                  `- error: generic parameter 'U' could not be inferred
174 |                                   options: options,
175 |                                   completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1095:42: error: cannot find type 'DispatchQueue' in scope
1093 |     public func aggregate(_ pipeline: [[String: Encodable]],
1094 |                           options: API.Options = [],
1095 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
1096 |                           completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1097 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:194:53: error: extra argument 'completion' in call
192 |             self.aggregate(pipeline,
193 |                            options: options,
194 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
195 |         }
196 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1220:63: error: cannot find type 'DispatchQueue' in scope
1218 |                                                usingMongoDB: Bool = false,
1219 |                                                options: API.Options = [],
1220 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1221 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1222 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:223:60: error: extra argument 'completion' in call
221 |                                   usingMongoDB: usingMongoDB,
222 |                                   options: options,
223 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
224 |         }
225 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1319:41: error: cannot find type 'DispatchQueue' in scope
1317 |     public func distinct(_ key: String,
1318 |                          options: API.Options = [],
1319 |                          callbackQueue: DispatchQueue = .main,
     |                                         `- error: cannot find type 'DispatchQueue' in scope
1320 |                          completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1321 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:240:18: error: cannot call value of non-function type 'String?'
238 |                   options: API.Options = []) async throws -> [ResultType] {
239 |         try await withCheckedThrowingContinuation { continuation in
240 |             self.distinct(key,
    |                  `- error: cannot call value of non-function type 'String?'
241 |                           options: options,
242 |                           completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1402:62: error: cannot find type 'DispatchQueue' in scope
1400 |                                               usingMongoDB: Bool = false,
1401 |                                               options: API.Options = [],
1402 |                                               callbackQueue: DispatchQueue = .main,
     |                                                              `- error: cannot find type 'DispatchQueue' in scope
1403 |                                               completion: @escaping (Result<[U], ParseError>) -> Void) {
1404 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:271:59: error: extra argument 'completion' in call
269 |                                  usingMongoDB: usingMongoDB,
270 |                                  options: options,
271 |                                  completion: continuation.resume)
    |                                                           `- error: extra argument 'completion' in call
272 |         }
273 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:48:26: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  46 |     }
  47 |
  48 |     struct AggregateBody<T>: Codable where T: ParseObject {
     |                          `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  49 |         let pipeline: [[String: AnyCodable]]?
  50 |         let hint: AnyCodable?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:79:25: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  77 |     }
  78 |
  79 |     struct DistinctBody<T>: Codable where T: ParseObject {
     |                         `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  80 |         let hint: AnyCodable?
  81 |         let explain: Bool?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:589:21: error: generic parameter 'U' could not be inferred
 587 |         if !usingMongoDB {
 588 |             do {
 589 |                 try findExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 590 |                                                       callbackQueue: callbackQueue) { result in
 591 |                     completion(result)
     :
1559 |     }
1560 |
1561 |     func findExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainCommand()'
1562 |         var query = self
1563 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:602:21: error: generic parameter 'U' could not be inferred
 600 |         } else {
 601 |             do {
 602 |                 try findExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 603 |                                                            callbackQueue: callbackQueue) { result in
 604 |                     completion(result)
     :
1687 |     }
1688 |
1689 |     func findExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainMongoCommand()'
1690 |         var query = self
1691 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:646:21: error: cannot find 'DispatchQueue' in scope
 644 |         }
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
     |                     `- error: cannot find 'DispatchQueue' in scope
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:647:41: error: cannot infer contextual base in reference to member 'default'
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
     |                                         `- error: cannot infer contextual base in reference to member 'default'
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:648:48: error: cannot infer contextual base in reference to member 'concurrent'
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
     |                                                `- error: cannot infer contextual base in reference to member 'concurrent'
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:649:58: error: cannot infer contextual base in reference to member 'inherit'
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
     |                                                          `- error: cannot infer contextual base in reference to member 'inherit'
 650 |                                   target: nil)
 651 |         queue.sync {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:650:43: error: 'nil' requires a contextual type
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
     |                                           `- error: 'nil' requires a contextual type
 651 |         queue.sync {
 652 |
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:800:21: error: generic parameter 'U' could not be inferred
 798 |         if !usingMongoDB {
 799 |             do {
 800 |                 try firstExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 801 |                                                        callbackQueue: callbackQueue) { result in
 802 |                     completion(result)
     :
1577 |     }
1578 |
1579 |     func firstExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainCommand()'
1580 |         var query = self
1581 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:813:21: error: generic parameter 'U' could not be inferred
 811 |         } else {
 812 |             do {
 813 |                 try firstExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 814 |                                                             callbackQueue: callbackQueue) { result in
 815 |                     completion(result)
     :
1705 |     }
1706 |
1707 |     func firstExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainMongoCommand()'
1708 |         var query = self
1709 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:926:21: error: generic parameter 'U' could not be inferred
 924 |         if !usingMongoDB {
 925 |             do {
 926 |                 try countExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 927 |                                                        callbackQueue: callbackQueue) { result in
 928 |                     completion(result)
     :
1610 |     }
1611 |
1612 |     func countExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainCommand()'
1613 |         var query = self
1614 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:939:21: error: generic parameter 'U' could not be inferred
 937 |         } else {
 938 |             do {
 939 |                 try countExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 940 |                                                             callbackQueue: callbackQueue) { result in
 941 |                     completion(result)
     :
1734 |     }
1735 |
1736 |     func countExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainMongoCommand()'
1737 |         var query = self
1738 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1012:21: error: generic parameter 'U' could not be inferred
1010 |         if !usingMongoDB {
1011 |             do {
1012 |                 try withCountExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1013 |                                                            callbackQueue: callbackQueue) { result in
1014 |                     completion(result)
     :
1630 |     }
1631 |
1632 |     func withCountExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainCommand()'
1633 |         var query = self
1634 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1025:21: error: generic parameter 'U' could not be inferred
1023 |         } else {
1024 |             do {
1025 |                 try withCountExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1026 |                                                             callbackQueue: callbackQueue) { result in
1027 |                     completion(result)
     :
1754 |     }
1755 |
1756 |     func withCountExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainMongoCommand()'
1757 |         var query = self
1758 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1256:27: error: generic parameter 'U' could not be inferred
1254 |         if !usingMongoDB {
1255 |             do {
1256 |                 try query.aggregateExplainCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1257 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1258 |                         completion(result)
     :
1649 |     }
1650 |
1651 |     func aggregateExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainCommand()'
1652 |         var query = self
1653 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1269:27: error: generic parameter 'U' could not be inferred
1267 |         } else {
1268 |             do {
1269 |                 try query.aggregateExplainMongoCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1270 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1271 |                         completion(result)
     :
1774 |
1775 |     // swiftlint:disable:next line_length
1776 |     func aggregateExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainMongoCommand()'
1777 |         var query = self
1778 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1414:21: error: generic parameter 'U' could not be inferred
1412 |         if !usingMongoDB {
1413 |             do {
1414 |                 try distinctExplainCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1415 |                     .executeAsync(options: options,
1416 |                                   callbackQueue: callbackQueue) { result in
     :
1669 |
1670 |     // swiftlint:disable:next line_length
1671 |     func distinctExplainCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainCommand(key:)'
1672 |         var query = self
1673 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1428:21: error: generic parameter 'U' could not be inferred
1426 |         } else {
1427 |             do {
1428 |                 try distinctExplainMongoCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1429 |                     .executeAsync(options: options,
1430 |                                   callbackQueue: callbackQueue) { result in
     :
1794 |
1795 |     // swiftlint:disable:next line_length
1796 |     func distinctExplainMongoCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainMongoCommand(key:)'
1797 |         var query = self
1798 |         query.explain = true
[183/184] Compiling ParseSwift QueryViewModel.swift
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:174:37: error: cannot find type 'DispatchQueue' in scope
172 |     */
173 |     public func send(options: API.Options = [],
174 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
175 |                      completion: @escaping (Result<String, ParseError>) -> Void) {
176 |         if expirationTime != nil && expirationInterval != nil {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:238:37: error: cannot find type 'DispatchQueue' in scope
236 |     func fetchStatus(_ statusId: String,
237 |                      options: API.Options = [],
238 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
239 |                      completion: @escaping (Result<ParsePushStatus<V>, ParseError>) -> Void) {
240 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/API/API.swift:166:26: error: cannot find type 'URLRequest' in scope
164 |         /// [documentation](https://developer.apple.com/documentation/foundation/url_loading_system/accessing_cached_data)
165 |         /// for more info.
166 |         case cachePolicy(URLRequest.CachePolicy)
    |                          `- error: cannot find type 'URLRequest' in scope
167 |
168 |         public func hash(into hasher: inout Hasher) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:190:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
188 |         var options = options
189 |         options.insert(.useMasterKey)
190 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
191 |         sendCommand()
192 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand.swift:61:42: error: cannot find type 'DispatchQueue' in scope
 59 |         // MARK: Asynchronous Execution
 60 |         func executeAsync(options: API.Options,
 61 |                           callbackQueue: DispatchQueue,
    |                                          `- error: cannot find type 'DispatchQueue' in scope
 62 |                           completion: @escaping(Result<U, ParseError>) -> Void) {
 63 |
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand+async.swift:18:38: error: cannot find type 'DispatchQueue' in scope
16 |     // MARK: Asynchronous Execution
17 |     func executeAsync(options: API.Options,
18 |                       callbackQueue: DispatchQueue) async throws -> U {
   |                                      `- error: cannot find type 'DispatchQueue' in scope
19 |         try await withCheckedThrowingContinuation { continuation in
20 |             self.executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:242:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
240 |         var options = options
241 |         options.insert(.useMasterKey)
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:18:53: error: cannot find type 'DispatchQueue' in scope
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:745:38: error: cannot find type 'DispatchQueue' in scope
 743 |     */
 744 |     public func first(options: API.Options = [],
 745 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 746 |                       completion: @escaping (Result<ResultType, ParseError>) -> Void) {
 747 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:82:31: error: cannot find type 'DispatchQueue' in scope
80 |       `error` will be `nil` if `result` is set OR if the query succeeded, but found no results.
81 |     */
82 |     func first(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<ResultType, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
83 |         first(options: [], callbackQueue: callbackQueue, completion: completion)
84 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:244:51: error: extra argument 'completion' in call
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
    |                                                   `- error: extra argument 'completion' in call
245 |     }
246 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:263:38: error: cannot find type 'DispatchQueue' in scope
261 |     */
262 |     public func fetch(options: API.Options = [],
263 |                       callbackQueue: DispatchQueue = .main,
    |                                      `- error: cannot find type 'DispatchQueue' in scope
264 |                       completion: @escaping (Result<Self, ParseError>) -> Void) {
265 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:27:49: error: extra argument 'completion' in call
 25 |         try await withCheckedThrowingContinuation { continuation in
 26 |             self.fetch(options: options,
 27 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 28 |         }
 29 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:300:39: error: cannot find type 'DispatchQueue' in scope
298 |     */
299 |     public func create(options: API.Options = [],
300 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
301 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
302 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:45:50: error: extra argument 'completion' in call
 43 |         try await withCheckedThrowingContinuation { continuation in
 44 |             self.create(options: options,
 45 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 46 |         }
 47 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:325:39: error: cannot find type 'DispatchQueue' in scope
323 |     */
324 |     public func update(options: API.Options = [],
325 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
326 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
327 |         var mutableSchema = self
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:63:50: error: extra argument 'completion' in call
 61 |         try await withCheckedThrowingContinuation { continuation in
 62 |             self.update(options: options,
 63 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 64 |         }
 65 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:379:24: error: cannot find type 'DispatchQueue' in scope
377 |     public func purge(
378 |         options: API.Options = [],
379 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
380 |         completion: @escaping (Result<Void, ParseError>) -> Void
381 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:82:50: error: extra argument 'completion' in call
 80 |         let result = try await withCheckedThrowingContinuation { continuation in
 81 |             self.purge(options: options,
 82 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 83 |         }
 84 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:417:24: error: cannot find type 'DispatchQueue' in scope
415 |     public func delete(
416 |         options: API.Options = [],
417 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
418 |         completion: @escaping (Result<Void, ParseError>) -> Void
419 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:105:50: error: extra argument 'completion' in call
103 |         let result = try await withCheckedThrowingContinuation { continuation in
104 |             self.delete(options: options,
105 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
106 |         }
107 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:267:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
265 |         var options = options
266 |         options.insert(.useMasterKey)
267 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
268 |         fetchCommand()
269 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:304:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
302 |         var options = options
303 |         options.insert(.useMasterKey)
304 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
305 |         createCommand()
306 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:335:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
333 |         var options = options
334 |         options.insert(.useMasterKey)
335 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
336 |         mutableSchema.updateCommand()
337 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:384:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
382 |         var options = options
383 |         options.insert(.useMasterKey)
384 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
385 |         purgeCommand().executeAsync(options: options,
386 |                                         callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:422:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
420 |         var options = options
421 |         options.insert(.useMasterKey)
422 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
423 |         deleteCommand().executeAsync(options: options,
424 |                                          callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:135:31: error: cannot find type 'DispatchQueue' in scope
133 |     func fetch(includeKeys: [String]? = nil,
134 |                options: API.Options = [],
135 |                callbackQueue: DispatchQueue = .main,
    |                               `- error: cannot find type 'DispatchQueue' in scope
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer+async.swift:29:49: error: extra argument 'completion' in call
27 |             self.fetch(includeKeys: includeKeys,
28 |                        options: options,
29 |                        completion: continuation.resume)
   |                                                 `- error: extra argument 'completion' in call
30 |         }
31 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:113:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
111 |                options: API.Options = []) throws -> T {
112 |         var options = options
113 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
114 |         let path = API.Endpoint.object(className: className, objectId: objectId)
115 |         return try API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:138:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
138 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
139 |         let path = API.Endpoint.object(className: className, objectId: objectId)
140 |         API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:16:52: error: cannot find type 'DispatchQueue' in scope
14 |     func first(options: API.Options) throws -> ResultType
15 |     func count(options: API.Options) throws -> Int
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
   |                                                    `- error: cannot find type 'DispatchQueue' in scope
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:540:37: error: cannot find type 'DispatchQueue' in scope
 538 |     */
 539 |     public func find(options: API.Options = [],
 540 |                      callbackQueue: DispatchQueue = .main,
     |                                     `- error: cannot find type 'DispatchQueue' in scope
 541 |                      completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 542 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:67:30: error: cannot find type 'DispatchQueue' in scope
65 |       It should have the following argument signature: `(Result<[ResultType], ParseError>)`
66 |     */
67 |     func find(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
   |                              `- error: cannot find type 'DispatchQueue' in scope
68 |         find(options: [], callbackQueue: callbackQueue, completion: completion)
69 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:25:48: error: extra argument 'completion' in call
 23 |         try await withCheckedThrowingContinuation { continuation in
 24 |             self.find(options: options,
 25 |                       completion: continuation.resume)
    |                                                `- error: extra argument 'completion' in call
 26 |         }
 27 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:579:58: error: cannot find type 'DispatchQueue' in scope
 577 |     public func findExplain<U: Decodable>(usingMongoDB: Bool = false,
 578 |                                           options: API.Options = [],
 579 |                                           callbackQueue: DispatchQueue = .main,
     |                                                          `- error: cannot find type 'DispatchQueue' in scope
 580 |                                           completion: @escaping (Result<[U], ParseError>) -> Void) {
 581 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:48:55: error: extra argument 'completion' in call
 46 |             self.findExplain(usingMongoDB: usingMongoDB,
 47 |                              options: options,
 48 |                              completion: continuation.resume)
    |                                                       `- error: extra argument 'completion' in call
 49 |         }
 50 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:631:40: error: cannot find type 'DispatchQueue' in scope
 629 |     public func findAll(batchLimit limit: Int? = nil,
 630 |                         options: API.Options = [],
 631 |                         callbackQueue: DispatchQueue = .main,
     |                                        `- error: cannot find type 'DispatchQueue' in scope
 632 |                         completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 633 |         if self.limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:66:51: error: extra argument 'completion' in call
 64 |             self.findAll(batchLimit: batchLimit,
 65 |                          options: options,
 66 |                          completion: continuation.resume)
    |                                                   `- error: extra argument 'completion' in call
 67 |         }
 68 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:79:49: error: extra argument 'completion' in call
 77 |         try await withCheckedThrowingContinuation { continuation in
 78 |             self.first(options: options,
 79 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 80 |         }
 81 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:788:59: error: cannot find type 'DispatchQueue' in scope
 786 |     public func firstExplain<U: Decodable>(usingMongoDB: Bool = false,
 787 |                                            options: API.Options = [],
 788 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 789 |                                            completion: @escaping (Result<U, ParseError>) -> Void) {
 790 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:102:56: error: extra argument 'completion' in call
100 |             self.firstExplain(usingMongoDB: usingMongoDB,
101 |                               options: options,
102 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
103 |         }
104 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:20:53: error: cannot find type 'DispatchQueue' in scope
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
21 |                completion: @escaping (Result<Int, ParseError>) -> Void)
22 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:877:38: error: cannot find type 'DispatchQueue' in scope
 875 |     */
 876 |     public func count(options: API.Options = [],
 877 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 878 |                       completion: @escaping (Result<Int, ParseError>) -> Void) {
 879 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:93:31: error: cannot find type 'DispatchQueue' in scope
91 |       It should have the following argument signature: `^(int count, ParseError *error)`
92 |     */
93 |     func count(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<Int, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
94 |         count(options: [], callbackQueue: callbackQueue, completion: completion)
95 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:115:49: error: extra argument 'completion' in call
113 |         try await withCheckedThrowingContinuation { continuation in
114 |             self.count(options: options,
115 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
116 |         }
117 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:916:59: error: cannot find type 'DispatchQueue' in scope
 914 |     public func countExplain<U: Decodable>(usingMongoDB: Bool = false,
 915 |                                            options: API.Options = [],
 916 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 917 |                                            completion: @escaping (Result<[U], ParseError>) -> Void) {
 918 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:138:56: error: extra argument 'completion' in call
136 |             self.countExplain(usingMongoDB: usingMongoDB,
137 |                               options: options,
138 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
139 |         }
140 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:963:42: error: cannot find type 'DispatchQueue' in scope
 961 |     */
 962 |     public func withCount(options: API.Options = [],
 963 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
 964 |                           completion: @escaping (Result<([ResultType], Int), ParseError>) -> Void) {
 965 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:152:53: error: extra argument 'completion' in call
150 |         try await withCheckedThrowingContinuation { continuation in
151 |             self.withCount(options: options,
152 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
153 |         }
154 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1002:63: error: cannot find type 'DispatchQueue' in scope
1000 |     public func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
1001 |                                                options: API.Options = [],
1002 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1003 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1004 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:175:60: error: extra argument 'completion' in call
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
174 |                                   options: options,
175 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
176 |         }
177 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:173:18: error: generic parameter 'U' could not be inferred
168 |      [here](https://github.com/parse-community/parse-server/pull/7440).
169 |     */
170 |     func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
    |          `- note: in call to function 'withCountExplain(usingMongoDB:options:)'
171 |                                         options: API.Options = []) async throws -> [U] {
172 |         try await withCheckedThrowingContinuation { continuation in
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
    |                  `- error: generic parameter 'U' could not be inferred
174 |                                   options: options,
175 |                                   completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1095:42: error: cannot find type 'DispatchQueue' in scope
1093 |     public func aggregate(_ pipeline: [[String: Encodable]],
1094 |                           options: API.Options = [],
1095 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
1096 |                           completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1097 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:194:53: error: extra argument 'completion' in call
192 |             self.aggregate(pipeline,
193 |                            options: options,
194 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
195 |         }
196 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1220:63: error: cannot find type 'DispatchQueue' in scope
1218 |                                                usingMongoDB: Bool = false,
1219 |                                                options: API.Options = [],
1220 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1221 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1222 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:223:60: error: extra argument 'completion' in call
221 |                                   usingMongoDB: usingMongoDB,
222 |                                   options: options,
223 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
224 |         }
225 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1319:41: error: cannot find type 'DispatchQueue' in scope
1317 |     public func distinct(_ key: String,
1318 |                          options: API.Options = [],
1319 |                          callbackQueue: DispatchQueue = .main,
     |                                         `- error: cannot find type 'DispatchQueue' in scope
1320 |                          completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1321 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:240:18: error: cannot call value of non-function type 'String?'
238 |                   options: API.Options = []) async throws -> [ResultType] {
239 |         try await withCheckedThrowingContinuation { continuation in
240 |             self.distinct(key,
    |                  `- error: cannot call value of non-function type 'String?'
241 |                           options: options,
242 |                           completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1402:62: error: cannot find type 'DispatchQueue' in scope
1400 |                                               usingMongoDB: Bool = false,
1401 |                                               options: API.Options = [],
1402 |                                               callbackQueue: DispatchQueue = .main,
     |                                                              `- error: cannot find type 'DispatchQueue' in scope
1403 |                                               completion: @escaping (Result<[U], ParseError>) -> Void) {
1404 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:271:59: error: extra argument 'completion' in call
269 |                                  usingMongoDB: usingMongoDB,
270 |                                  options: options,
271 |                                  completion: continuation.resume)
    |                                                           `- error: extra argument 'completion' in call
272 |         }
273 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:48:26: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  46 |     }
  47 |
  48 |     struct AggregateBody<T>: Codable where T: ParseObject {
     |                          `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  49 |         let pipeline: [[String: AnyCodable]]?
  50 |         let hint: AnyCodable?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:79:25: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  77 |     }
  78 |
  79 |     struct DistinctBody<T>: Codable where T: ParseObject {
     |                         `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  80 |         let hint: AnyCodable?
  81 |         let explain: Bool?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:589:21: error: generic parameter 'U' could not be inferred
 587 |         if !usingMongoDB {
 588 |             do {
 589 |                 try findExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 590 |                                                       callbackQueue: callbackQueue) { result in
 591 |                     completion(result)
     :
1559 |     }
1560 |
1561 |     func findExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainCommand()'
1562 |         var query = self
1563 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:602:21: error: generic parameter 'U' could not be inferred
 600 |         } else {
 601 |             do {
 602 |                 try findExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 603 |                                                            callbackQueue: callbackQueue) { result in
 604 |                     completion(result)
     :
1687 |     }
1688 |
1689 |     func findExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainMongoCommand()'
1690 |         var query = self
1691 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:646:21: error: cannot find 'DispatchQueue' in scope
 644 |         }
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
     |                     `- error: cannot find 'DispatchQueue' in scope
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:647:41: error: cannot infer contextual base in reference to member 'default'
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
     |                                         `- error: cannot infer contextual base in reference to member 'default'
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:648:48: error: cannot infer contextual base in reference to member 'concurrent'
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
     |                                                `- error: cannot infer contextual base in reference to member 'concurrent'
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:649:58: error: cannot infer contextual base in reference to member 'inherit'
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
     |                                                          `- error: cannot infer contextual base in reference to member 'inherit'
 650 |                                   target: nil)
 651 |         queue.sync {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:650:43: error: 'nil' requires a contextual type
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
     |                                           `- error: 'nil' requires a contextual type
 651 |         queue.sync {
 652 |
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:800:21: error: generic parameter 'U' could not be inferred
 798 |         if !usingMongoDB {
 799 |             do {
 800 |                 try firstExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 801 |                                                        callbackQueue: callbackQueue) { result in
 802 |                     completion(result)
     :
1577 |     }
1578 |
1579 |     func firstExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainCommand()'
1580 |         var query = self
1581 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:813:21: error: generic parameter 'U' could not be inferred
 811 |         } else {
 812 |             do {
 813 |                 try firstExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 814 |                                                             callbackQueue: callbackQueue) { result in
 815 |                     completion(result)
     :
1705 |     }
1706 |
1707 |     func firstExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainMongoCommand()'
1708 |         var query = self
1709 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:926:21: error: generic parameter 'U' could not be inferred
 924 |         if !usingMongoDB {
 925 |             do {
 926 |                 try countExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 927 |                                                        callbackQueue: callbackQueue) { result in
 928 |                     completion(result)
     :
1610 |     }
1611 |
1612 |     func countExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainCommand()'
1613 |         var query = self
1614 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:939:21: error: generic parameter 'U' could not be inferred
 937 |         } else {
 938 |             do {
 939 |                 try countExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 940 |                                                             callbackQueue: callbackQueue) { result in
 941 |                     completion(result)
     :
1734 |     }
1735 |
1736 |     func countExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainMongoCommand()'
1737 |         var query = self
1738 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1012:21: error: generic parameter 'U' could not be inferred
1010 |         if !usingMongoDB {
1011 |             do {
1012 |                 try withCountExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1013 |                                                            callbackQueue: callbackQueue) { result in
1014 |                     completion(result)
     :
1630 |     }
1631 |
1632 |     func withCountExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainCommand()'
1633 |         var query = self
1634 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1025:21: error: generic parameter 'U' could not be inferred
1023 |         } else {
1024 |             do {
1025 |                 try withCountExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1026 |                                                             callbackQueue: callbackQueue) { result in
1027 |                     completion(result)
     :
1754 |     }
1755 |
1756 |     func withCountExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainMongoCommand()'
1757 |         var query = self
1758 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1256:27: error: generic parameter 'U' could not be inferred
1254 |         if !usingMongoDB {
1255 |             do {
1256 |                 try query.aggregateExplainCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1257 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1258 |                         completion(result)
     :
1649 |     }
1650 |
1651 |     func aggregateExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainCommand()'
1652 |         var query = self
1653 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1269:27: error: generic parameter 'U' could not be inferred
1267 |         } else {
1268 |             do {
1269 |                 try query.aggregateExplainMongoCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1270 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1271 |                         completion(result)
     :
1774 |
1775 |     // swiftlint:disable:next line_length
1776 |     func aggregateExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainMongoCommand()'
1777 |         var query = self
1778 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1414:21: error: generic parameter 'U' could not be inferred
1412 |         if !usingMongoDB {
1413 |             do {
1414 |                 try distinctExplainCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1415 |                     .executeAsync(options: options,
1416 |                                   callbackQueue: callbackQueue) { result in
     :
1669 |
1670 |     // swiftlint:disable:next line_length
1671 |     func distinctExplainCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainCommand(key:)'
1672 |         var query = self
1673 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1428:21: error: generic parameter 'U' could not be inferred
1426 |         } else {
1427 |             do {
1428 |                 try distinctExplainMongoCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1429 |                     .executeAsync(options: options,
1430 |                                   callbackQueue: callbackQueue) { result in
     :
1794 |
1795 |     // swiftlint:disable:next line_length
1796 |     func distinctExplainMongoCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainMongoCommand(key:)'
1797 |         var query = self
1798 |         query.explain = true
[184/184] Compiling ParseSwift QueryWhere.swift
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:174:37: error: cannot find type 'DispatchQueue' in scope
172 |     */
173 |     public func send(options: API.Options = [],
174 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
175 |                      completion: @escaping (Result<String, ParseError>) -> Void) {
176 |         if expirationTime != nil && expirationInterval != nil {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:238:37: error: cannot find type 'DispatchQueue' in scope
236 |     func fetchStatus(_ statusId: String,
237 |                      options: API.Options = [],
238 |                      callbackQueue: DispatchQueue = .main,
    |                                     `- error: cannot find type 'DispatchQueue' in scope
239 |                      completion: @escaping (Result<ParsePushStatus<V>, ParseError>) -> Void) {
240 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/API/API.swift:166:26: error: cannot find type 'URLRequest' in scope
164 |         /// [documentation](https://developer.apple.com/documentation/foundation/url_loading_system/accessing_cached_data)
165 |         /// for more info.
166 |         case cachePolicy(URLRequest.CachePolicy)
    |                          `- error: cannot find type 'URLRequest' in scope
167 |
168 |         public func hash(into hasher: inout Hasher) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:190:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
188 |         var options = options
189 |         options.insert(.useMasterKey)
190 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
191 |         sendCommand()
192 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand.swift:61:42: error: cannot find type 'DispatchQueue' in scope
 59 |         // MARK: Asynchronous Execution
 60 |         func executeAsync(options: API.Options,
 61 |                           callbackQueue: DispatchQueue,
    |                                          `- error: cannot find type 'DispatchQueue' in scope
 62 |                           completion: @escaping(Result<U, ParseError>) -> Void) {
 63 |
/host/spi-builder-workspace/Sources/ParseSwift/API/API+NonParseBodyCommand+async.swift:18:38: error: cannot find type 'DispatchQueue' in scope
16 |     // MARK: Asynchronous Execution
17 |     func executeAsync(options: API.Options,
18 |                       callbackQueue: DispatchQueue) async throws -> U {
   |                                      `- error: cannot find type 'DispatchQueue' in scope
19 |         try await withCheckedThrowingContinuation { continuation in
20 |             self.executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:242:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
240 |         var options = options
241 |         options.insert(.useMasterKey)
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:18:53: error: cannot find type 'DispatchQueue' in scope
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:745:38: error: cannot find type 'DispatchQueue' in scope
 743 |     */
 744 |     public func first(options: API.Options = [],
 745 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 746 |                       completion: @escaping (Result<ResultType, ParseError>) -> Void) {
 747 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:82:31: error: cannot find type 'DispatchQueue' in scope
80 |       `error` will be `nil` if `result` is set OR if the query succeeded, but found no results.
81 |     */
82 |     func first(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<ResultType, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
83 |         first(options: [], callbackQueue: callbackQueue, completion: completion)
84 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParsePush.swift:244:51: error: extra argument 'completion' in call
242 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
243 |         let query = ParsePushStatus<V>.query("objectId" == statusId)
244 |         query.first(options: options, completion: completion)
    |                                                   `- error: extra argument 'completion' in call
245 |     }
246 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:263:38: error: cannot find type 'DispatchQueue' in scope
261 |     */
262 |     public func fetch(options: API.Options = [],
263 |                       callbackQueue: DispatchQueue = .main,
    |                                      `- error: cannot find type 'DispatchQueue' in scope
264 |                       completion: @escaping (Result<Self, ParseError>) -> Void) {
265 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:27:49: error: extra argument 'completion' in call
 25 |         try await withCheckedThrowingContinuation { continuation in
 26 |             self.fetch(options: options,
 27 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 28 |         }
 29 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:300:39: error: cannot find type 'DispatchQueue' in scope
298 |     */
299 |     public func create(options: API.Options = [],
300 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
301 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
302 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:45:50: error: extra argument 'completion' in call
 43 |         try await withCheckedThrowingContinuation { continuation in
 44 |             self.create(options: options,
 45 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 46 |         }
 47 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:325:39: error: cannot find type 'DispatchQueue' in scope
323 |     */
324 |     public func update(options: API.Options = [],
325 |                        callbackQueue: DispatchQueue = .main,
    |                                       `- error: cannot find type 'DispatchQueue' in scope
326 |                        completion: @escaping (Result<Self, ParseError>) -> Void) {
327 |         var mutableSchema = self
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:63:50: error: extra argument 'completion' in call
 61 |         try await withCheckedThrowingContinuation { continuation in
 62 |             self.update(options: options,
 63 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 64 |         }
 65 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:379:24: error: cannot find type 'DispatchQueue' in scope
377 |     public func purge(
378 |         options: API.Options = [],
379 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
380 |         completion: @escaping (Result<Void, ParseError>) -> Void
381 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:82:50: error: extra argument 'completion' in call
 80 |         let result = try await withCheckedThrowingContinuation { continuation in
 81 |             self.purge(options: options,
 82 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
 83 |         }
 84 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:417:24: error: cannot find type 'DispatchQueue' in scope
415 |     public func delete(
416 |         options: API.Options = [],
417 |         callbackQueue: DispatchQueue = .main,
    |                        `- error: cannot find type 'DispatchQueue' in scope
418 |         completion: @escaping (Result<Void, ParseError>) -> Void
419 |     ) {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema+async.swift:105:50: error: extra argument 'completion' in call
103 |         let result = try await withCheckedThrowingContinuation { continuation in
104 |             self.delete(options: options,
105 |                         completion: continuation.resume)
    |                                                  `- error: extra argument 'completion' in call
106 |         }
107 |         if case let .failure(error) = result {
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:267:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
265 |         var options = options
266 |         options.insert(.useMasterKey)
267 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
268 |         fetchCommand()
269 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:304:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
302 |         var options = options
303 |         options.insert(.useMasterKey)
304 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
305 |         createCommand()
306 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:335:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
333 |         var options = options
334 |         options.insert(.useMasterKey)
335 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
336 |         mutableSchema.updateCommand()
337 |             .executeAsync(options: options,
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:384:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
382 |         var options = options
383 |         options.insert(.useMasterKey)
384 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
385 |         purgeCommand().executeAsync(options: options,
386 |                                         callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/ParseSchema.swift:422:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
420 |         var options = options
421 |         options.insert(.useMasterKey)
422 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
423 |         deleteCommand().executeAsync(options: options,
424 |                                          callbackQueue: callbackQueue) { result in
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:135:31: error: cannot find type 'DispatchQueue' in scope
133 |     func fetch(includeKeys: [String]? = nil,
134 |                options: API.Options = [],
135 |                callbackQueue: DispatchQueue = .main,
    |                               `- error: cannot find type 'DispatchQueue' in scope
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer+async.swift:29:49: error: extra argument 'completion' in call
27 |             self.fetch(includeKeys: includeKeys,
28 |                        options: options,
29 |                        completion: continuation.resume)
   |                                                 `- error: extra argument 'completion' in call
30 |         }
31 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:113:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
111 |                options: API.Options = []) throws -> T {
112 |         var options = options
113 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
114 |         let path = API.Endpoint.object(className: className, objectId: objectId)
115 |         return try API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Pointer.swift:138:38: error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
136 |                completion: @escaping (Result<T, ParseError>) -> Void) {
137 |         var options = options
138 |         options.insert(.cachePolicy(.reloadIgnoringLocalCacheData))
    |                                      `- error: cannot infer contextual base in reference to member 'reloadIgnoringLocalCacheData'
139 |         let path = API.Endpoint.object(className: className, objectId: objectId)
140 |         API.NonParseBodyCommand<NoBody, T>(method: .GET,
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:16:52: error: cannot find type 'DispatchQueue' in scope
14 |     func first(options: API.Options) throws -> ResultType
15 |     func count(options: API.Options) throws -> Int
16 |     func find(options: API.Options, callbackQueue: DispatchQueue,
   |                                                    `- error: cannot find type 'DispatchQueue' in scope
17 |               completion: @escaping (Result<[ResultType], ParseError>) -> Void)
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:540:37: error: cannot find type 'DispatchQueue' in scope
 538 |     */
 539 |     public func find(options: API.Options = [],
 540 |                      callbackQueue: DispatchQueue = .main,
     |                                     `- error: cannot find type 'DispatchQueue' in scope
 541 |                      completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 542 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:67:30: error: cannot find type 'DispatchQueue' in scope
65 |       It should have the following argument signature: `(Result<[ResultType], ParseError>)`
66 |     */
67 |     func find(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
   |                              `- error: cannot find type 'DispatchQueue' in scope
68 |         find(options: [], callbackQueue: callbackQueue, completion: completion)
69 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:25:48: error: extra argument 'completion' in call
 23 |         try await withCheckedThrowingContinuation { continuation in
 24 |             self.find(options: options,
 25 |                       completion: continuation.resume)
    |                                                `- error: extra argument 'completion' in call
 26 |         }
 27 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:579:58: error: cannot find type 'DispatchQueue' in scope
 577 |     public func findExplain<U: Decodable>(usingMongoDB: Bool = false,
 578 |                                           options: API.Options = [],
 579 |                                           callbackQueue: DispatchQueue = .main,
     |                                                          `- error: cannot find type 'DispatchQueue' in scope
 580 |                                           completion: @escaping (Result<[U], ParseError>) -> Void) {
 581 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:48:55: error: extra argument 'completion' in call
 46 |             self.findExplain(usingMongoDB: usingMongoDB,
 47 |                              options: options,
 48 |                              completion: continuation.resume)
    |                                                       `- error: extra argument 'completion' in call
 49 |         }
 50 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:631:40: error: cannot find type 'DispatchQueue' in scope
 629 |     public func findAll(batchLimit limit: Int? = nil,
 630 |                         options: API.Options = [],
 631 |                         callbackQueue: DispatchQueue = .main,
     |                                        `- error: cannot find type 'DispatchQueue' in scope
 632 |                         completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
 633 |         if self.limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:66:51: error: extra argument 'completion' in call
 64 |             self.findAll(batchLimit: batchLimit,
 65 |                          options: options,
 66 |                          completion: continuation.resume)
    |                                                   `- error: extra argument 'completion' in call
 67 |         }
 68 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:79:49: error: extra argument 'completion' in call
 77 |         try await withCheckedThrowingContinuation { continuation in
 78 |             self.first(options: options,
 79 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
 80 |         }
 81 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:788:59: error: cannot find type 'DispatchQueue' in scope
 786 |     public func firstExplain<U: Decodable>(usingMongoDB: Bool = false,
 787 |                                            options: API.Options = [],
 788 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 789 |                                            completion: @escaping (Result<U, ParseError>) -> Void) {
 790 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:102:56: error: extra argument 'completion' in call
100 |             self.firstExplain(usingMongoDB: usingMongoDB,
101 |                               options: options,
102 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
103 |         }
104 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:20:53: error: cannot find type 'DispatchQueue' in scope
18 |     func first(options: API.Options, callbackQueue: DispatchQueue,
19 |                completion: @escaping (Result<ResultType, ParseError>) -> Void)
20 |     func count(options: API.Options, callbackQueue: DispatchQueue,
   |                                                     `- error: cannot find type 'DispatchQueue' in scope
21 |                completion: @escaping (Result<Int, ParseError>) -> Void)
22 | }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:877:38: error: cannot find type 'DispatchQueue' in scope
 875 |     */
 876 |     public func count(options: API.Options = [],
 877 |                       callbackQueue: DispatchQueue = .main,
     |                                      `- error: cannot find type 'DispatchQueue' in scope
 878 |                       completion: @escaping (Result<Int, ParseError>) -> Void) {
 879 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Protocols/Queryable.swift:93:31: error: cannot find type 'DispatchQueue' in scope
91 |       It should have the following argument signature: `^(int count, ParseError *error)`
92 |     */
93 |     func count(callbackQueue: DispatchQueue = .main, completion: @escaping (Result<Int, ParseError>) -> Void) {
   |                               `- error: cannot find type 'DispatchQueue' in scope
94 |         count(options: [], callbackQueue: callbackQueue, completion: completion)
95 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:115:49: error: extra argument 'completion' in call
113 |         try await withCheckedThrowingContinuation { continuation in
114 |             self.count(options: options,
115 |                        completion: continuation.resume)
    |                                                 `- error: extra argument 'completion' in call
116 |         }
117 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:916:59: error: cannot find type 'DispatchQueue' in scope
 914 |     public func countExplain<U: Decodable>(usingMongoDB: Bool = false,
 915 |                                            options: API.Options = [],
 916 |                                            callbackQueue: DispatchQueue = .main,
     |                                                           `- error: cannot find type 'DispatchQueue' in scope
 917 |                                            completion: @escaping (Result<[U], ParseError>) -> Void) {
 918 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:138:56: error: extra argument 'completion' in call
136 |             self.countExplain(usingMongoDB: usingMongoDB,
137 |                               options: options,
138 |                               completion: continuation.resume)
    |                                                        `- error: extra argument 'completion' in call
139 |         }
140 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:963:42: error: cannot find type 'DispatchQueue' in scope
 961 |     */
 962 |     public func withCount(options: API.Options = [],
 963 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
 964 |                           completion: @escaping (Result<([ResultType], Int), ParseError>) -> Void) {
 965 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:152:53: error: extra argument 'completion' in call
150 |         try await withCheckedThrowingContinuation { continuation in
151 |             self.withCount(options: options,
152 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
153 |         }
154 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1002:63: error: cannot find type 'DispatchQueue' in scope
1000 |     public func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
1001 |                                                options: API.Options = [],
1002 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1003 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1004 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:175:60: error: extra argument 'completion' in call
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
174 |                                   options: options,
175 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
176 |         }
177 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:173:18: error: generic parameter 'U' could not be inferred
168 |      [here](https://github.com/parse-community/parse-server/pull/7440).
169 |     */
170 |     func withCountExplain<U: Decodable>(usingMongoDB: Bool = false,
    |          `- note: in call to function 'withCountExplain(usingMongoDB:options:)'
171 |                                         options: API.Options = []) async throws -> [U] {
172 |         try await withCheckedThrowingContinuation { continuation in
173 |             self.withCountExplain(usingMongoDB: usingMongoDB,
    |                  `- error: generic parameter 'U' could not be inferred
174 |                                   options: options,
175 |                                   completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1095:42: error: cannot find type 'DispatchQueue' in scope
1093 |     public func aggregate(_ pipeline: [[String: Encodable]],
1094 |                           options: API.Options = [],
1095 |                           callbackQueue: DispatchQueue = .main,
     |                                          `- error: cannot find type 'DispatchQueue' in scope
1096 |                           completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1097 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:194:53: error: extra argument 'completion' in call
192 |             self.aggregate(pipeline,
193 |                            options: options,
194 |                            completion: continuation.resume)
    |                                                     `- error: extra argument 'completion' in call
195 |         }
196 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1220:63: error: cannot find type 'DispatchQueue' in scope
1218 |                                                usingMongoDB: Bool = false,
1219 |                                                options: API.Options = [],
1220 |                                                callbackQueue: DispatchQueue = .main,
     |                                                               `- error: cannot find type 'DispatchQueue' in scope
1221 |                                                completion: @escaping (Result<[U], ParseError>) -> Void) {
1222 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:223:60: error: extra argument 'completion' in call
221 |                                   usingMongoDB: usingMongoDB,
222 |                                   options: options,
223 |                                   completion: continuation.resume)
    |                                                            `- error: extra argument 'completion' in call
224 |         }
225 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1319:41: error: cannot find type 'DispatchQueue' in scope
1317 |     public func distinct(_ key: String,
1318 |                          options: API.Options = [],
1319 |                          callbackQueue: DispatchQueue = .main,
     |                                         `- error: cannot find type 'DispatchQueue' in scope
1320 |                          completion: @escaping (Result<[ResultType], ParseError>) -> Void) {
1321 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:240:18: error: cannot call value of non-function type 'String?'
238 |                   options: API.Options = []) async throws -> [ResultType] {
239 |         try await withCheckedThrowingContinuation { continuation in
240 |             self.distinct(key,
    |                  `- error: cannot call value of non-function type 'String?'
241 |                           options: options,
242 |                           completion: continuation.resume)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1402:62: error: cannot find type 'DispatchQueue' in scope
1400 |                                               usingMongoDB: Bool = false,
1401 |                                               options: API.Options = [],
1402 |                                               callbackQueue: DispatchQueue = .main,
     |                                                              `- error: cannot find type 'DispatchQueue' in scope
1403 |                                               completion: @escaping (Result<[U], ParseError>) -> Void) {
1404 |         if limit == 0 {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query+async.swift:271:59: error: extra argument 'completion' in call
269 |                                  usingMongoDB: usingMongoDB,
270 |                                  options: options,
271 |                                  completion: continuation.resume)
    |                                                           `- error: extra argument 'completion' in call
272 |         }
273 |     }
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:48:26: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  46 |     }
  47 |
  48 |     struct AggregateBody<T>: Codable where T: ParseObject {
     |                          `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  49 |         let pipeline: [[String: AnyCodable]]?
  50 |         let hint: AnyCodable?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:79:25: warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  13 |   The `Query` class defines a query that is used to query for `ParseObject`s.
  14 | */
  15 | public struct Query<T>: ParseTypeable where T: ParseObject {
     |                     `- note: 'T' previously declared here
  16 |     // interpolate as GET
  17 |     private let method: String = "GET"
     :
  77 |     }
  78 |
  79 |     struct DistinctBody<T>: Codable where T: ParseObject {
     |                         `- warning: generic parameter 'T' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
  80 |         let hint: AnyCodable?
  81 |         let explain: Bool?
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:589:21: error: generic parameter 'U' could not be inferred
 587 |         if !usingMongoDB {
 588 |             do {
 589 |                 try findExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 590 |                                                       callbackQueue: callbackQueue) { result in
 591 |                     completion(result)
     :
1559 |     }
1560 |
1561 |     func findExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainCommand()'
1562 |         var query = self
1563 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:602:21: error: generic parameter 'U' could not be inferred
 600 |         } else {
 601 |             do {
 602 |                 try findExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 603 |                                                            callbackQueue: callbackQueue) { result in
 604 |                     completion(result)
     :
1687 |     }
1688 |
1689 |     func findExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'findExplainMongoCommand()'
1690 |         var query = self
1691 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:646:21: error: cannot find 'DispatchQueue' in scope
 644 |         }
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
     |                     `- error: cannot find 'DispatchQueue' in scope
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:647:41: error: cannot infer contextual base in reference to member 'default'
 645 |         let uuid = UUID()
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
     |                                         `- error: cannot infer contextual base in reference to member 'default'
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:648:48: error: cannot infer contextual base in reference to member 'concurrent'
 646 |         let queue = DispatchQueue(label: "com.parse.findAll.\(uuid)",
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
     |                                                `- error: cannot infer contextual base in reference to member 'concurrent'
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:649:58: error: cannot infer contextual base in reference to member 'inherit'
 647 |                                   qos: .default,
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
     |                                                          `- error: cannot infer contextual base in reference to member 'inherit'
 650 |                                   target: nil)
 651 |         queue.sync {
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:650:43: error: 'nil' requires a contextual type
 648 |                                   attributes: .concurrent,
 649 |                                   autoreleaseFrequency: .inherit,
 650 |                                   target: nil)
     |                                           `- error: 'nil' requires a contextual type
 651 |         queue.sync {
 652 |
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:800:21: error: generic parameter 'U' could not be inferred
 798 |         if !usingMongoDB {
 799 |             do {
 800 |                 try firstExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 801 |                                                        callbackQueue: callbackQueue) { result in
 802 |                     completion(result)
     :
1577 |     }
1578 |
1579 |     func firstExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainCommand()'
1580 |         var query = self
1581 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:813:21: error: generic parameter 'U' could not be inferred
 811 |         } else {
 812 |             do {
 813 |                 try firstExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 814 |                                                             callbackQueue: callbackQueue) { result in
 815 |                     completion(result)
     :
1705 |     }
1706 |
1707 |     func firstExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, U> {
     |          `- note: in call to function 'firstExplainMongoCommand()'
1708 |         var query = self
1709 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:926:21: error: generic parameter 'U' could not be inferred
 924 |         if !usingMongoDB {
 925 |             do {
 926 |                 try countExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 927 |                                                        callbackQueue: callbackQueue) { result in
 928 |                     completion(result)
     :
1610 |     }
1611 |
1612 |     func countExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainCommand()'
1613 |         var query = self
1614 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:939:21: error: generic parameter 'U' could not be inferred
 937 |         } else {
 938 |             do {
 939 |                 try countExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
 940 |                                                             callbackQueue: callbackQueue) { result in
 941 |                     completion(result)
     :
1734 |     }
1735 |
1736 |     func countExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'countExplainMongoCommand()'
1737 |         var query = self
1738 |         query.limit = 1
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1012:21: error: generic parameter 'U' could not be inferred
1010 |         if !usingMongoDB {
1011 |             do {
1012 |                 try withCountExplainCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1013 |                                                            callbackQueue: callbackQueue) { result in
1014 |                     completion(result)
     :
1630 |     }
1631 |
1632 |     func withCountExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainCommand()'
1633 |         var query = self
1634 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1025:21: error: generic parameter 'U' could not be inferred
1023 |         } else {
1024 |             do {
1025 |                 try withCountExplainMongoCommand().executeAsync(options: options,
     |                     `- error: generic parameter 'U' could not be inferred
1026 |                                                             callbackQueue: callbackQueue) { result in
1027 |                     completion(result)
     :
1754 |     }
1755 |
1756 |     func withCountExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<Query<ResultType>, [U]> {
     |          `- note: in call to function 'withCountExplainMongoCommand()'
1757 |         var query = self
1758 |         query.isCount = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1256:27: error: generic parameter 'U' could not be inferred
1254 |         if !usingMongoDB {
1255 |             do {
1256 |                 try query.aggregateExplainCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1257 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1258 |                         completion(result)
     :
1649 |     }
1650 |
1651 |     func aggregateExplainCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainCommand()'
1652 |         var query = self
1653 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1269:27: error: generic parameter 'U' could not be inferred
1267 |         } else {
1268 |             do {
1269 |                 try query.aggregateExplainMongoCommand()
     |                           `- error: generic parameter 'U' could not be inferred
1270 |                     .executeAsync(options: options, callbackQueue: callbackQueue) { result in
1271 |                         completion(result)
     :
1774 |
1775 |     // swiftlint:disable:next line_length
1776 |     func aggregateExplainMongoCommand<U: Decodable>() throws -> API.NonParseBodyCommand<AggregateBody<ResultType>, [U]> {
     |          `- note: in call to function 'aggregateExplainMongoCommand()'
1777 |         var query = self
1778 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1414:21: error: generic parameter 'U' could not be inferred
1412 |         if !usingMongoDB {
1413 |             do {
1414 |                 try distinctExplainCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1415 |                     .executeAsync(options: options,
1416 |                                   callbackQueue: callbackQueue) { result in
     :
1669 |
1670 |     // swiftlint:disable:next line_length
1671 |     func distinctExplainCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainCommand(key:)'
1672 |         var query = self
1673 |         query.explain = true
/host/spi-builder-workspace/Sources/ParseSwift/Types/Query.swift:1428:21: error: generic parameter 'U' could not be inferred
1426 |         } else {
1427 |             do {
1428 |                 try distinctExplainMongoCommand(key: key)
     |                     `- error: generic parameter 'U' could not be inferred
1429 |                     .executeAsync(options: options,
1430 |                                   callbackQueue: callbackQueue) { result in
     :
1794 |
1795 |     // swiftlint:disable:next line_length
1796 |     func distinctExplainMongoCommand<U: Decodable>(key: String) throws -> API.NonParseBodyCommand<DistinctBody<ResultType>, [U]> {
     |          `- note: in call to function 'distinctExplainMongoCommand(key:)'
1797 |         var query = self
1798 |         query.explain = true
BUILD FAILURE 6.1 wasm