Swift Package Index

Build Information

Successful build of DuckDB, reference v1.1.3 (9583f4), with Swift 6.1 for macOS (SPM) on 2 Aug 2025 20:14:40 UTC.

Swift 6 data race errors: 38

Build Command

env DEVELOPER_DIR=/Applications/Xcode-16.3.0.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures

Build Log

 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Types/Date.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
23 | //  IN THE SOFTWARE.
24 |
25 | @_implementationOnly import Cduckdb
   |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
26 |
27 | /// A date in the Gregorian calendar
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/ResultSet.swift:185:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'ResultStorage' has non-sendable type 'UnsafeMutablePointer<duckdb_result>'; this is an error in the Swift 6 language mode
183 |   let columnCount: DBInt
184 |
185 |   private let ptr = UnsafeMutablePointer<duckdb_result>.allocate(capacity: 1)
    |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'ResultStorage' has non-sendable type 'UnsafeMutablePointer<duckdb_result>'; this is an error in the Swift 6 language mode
186 |
187 |   init(connection: Connection, sql: String) throws {
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
[333/352] Compiling DuckDB Appender.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Appender.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Column.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
[334/352] Compiling DuckDB CodingUserInfoKeys.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Appender.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Column.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
[335/352] Compiling DuckDB Column.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Appender.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Column.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
[336/352] Compiling DuckDB IntHuge.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Types/Interval.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
23 | //  IN THE SOFTWARE.
24 |
25 | @_implementationOnly import Cduckdb
   |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
26 |
27 | /// A period of time
[337/352] Compiling DuckDB Interval.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Types/Interval.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
23 | //  IN THE SOFTWARE.
24 |
25 | @_implementationOnly import Cduckdb
   |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
26 |
27 | /// A period of time
[338/352] Compiling DuckDB Vector.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/Vector.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/VectorElementDecoder.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/LogicalType.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/VectorElementDecoder.swift:32:14: warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'VectorElementDecoder' may have shared mutable state; this is an error in the Swift 6 language mode
 28 | // MARK: - Top Level Decoder
 29 |
 30 | final class VectorElementDecoder {
    |             `- note: class 'VectorElementDecoder' does not conform to the 'Sendable' protocol
 31 |
 32 |   static let `default` = VectorElementDecoder()
    |              |- warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'VectorElementDecoder' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'default' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 33 |
 34 |   func decode<T: Decodable>(_ type: T.Type, element: Vector.Element) throws -> T {
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/LogicalType.swift:83:14: warning: static property 'structCompatibleTypes' is not concurrency-safe because non-'Sendable' type '[DatabaseType]' may have shared mutable state; this is an error in the Swift 6 language mode
 81 | public extension LogicalType {
 82 |
 83 |   static let structCompatibleTypes = [DatabaseType.struct, .map]
    |              |- warning: static property 'structCompatibleTypes' is not concurrency-safe because non-'Sendable' type '[DatabaseType]' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'structCompatibleTypes' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |
 85 |   /// Properties associated with a struct type
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:39:15: note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
[339/352] Compiling DuckDB VectorElementDecoder.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/Vector.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/VectorElementDecoder.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/LogicalType.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/VectorElementDecoder.swift:32:14: warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'VectorElementDecoder' may have shared mutable state; this is an error in the Swift 6 language mode
 28 | // MARK: - Top Level Decoder
 29 |
 30 | final class VectorElementDecoder {
    |             `- note: class 'VectorElementDecoder' does not conform to the 'Sendable' protocol
 31 |
 32 |   static let `default` = VectorElementDecoder()
    |              |- warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'VectorElementDecoder' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'default' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 33 |
 34 |   func decode<T: Decodable>(_ type: T.Type, element: Vector.Element) throws -> T {
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/LogicalType.swift:83:14: warning: static property 'structCompatibleTypes' is not concurrency-safe because non-'Sendable' type '[DatabaseType]' may have shared mutable state; this is an error in the Swift 6 language mode
 81 | public extension LogicalType {
 82 |
 83 |   static let structCompatibleTypes = [DatabaseType.struct, .map]
    |              |- warning: static property 'structCompatibleTypes' is not concurrency-safe because non-'Sendable' type '[DatabaseType]' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'structCompatibleTypes' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |
 85 |   /// Properties associated with a struct type
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:39:15: note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
[340/352] Compiling DuckDB LogicalType.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/Vector.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/VectorElementDecoder.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/LogicalType.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/VectorElementDecoder.swift:32:14: warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'VectorElementDecoder' may have shared mutable state; this is an error in the Swift 6 language mode
 28 | // MARK: - Top Level Decoder
 29 |
 30 | final class VectorElementDecoder {
    |             `- note: class 'VectorElementDecoder' does not conform to the 'Sendable' protocol
 31 |
 32 |   static let `default` = VectorElementDecoder()
    |              |- warning: static property 'default' is not concurrency-safe because non-'Sendable' type 'VectorElementDecoder' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'default' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 33 |
 34 |   func decode<T: Decodable>(_ type: T.Type, element: Vector.Element) throws -> T {
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/LogicalType.swift:83:14: warning: static property 'structCompatibleTypes' is not concurrency-safe because non-'Sendable' type '[DatabaseType]' may have shared mutable state; this is an error in the Swift 6 language mode
 81 | public extension LogicalType {
 82 |
 83 |   static let structCompatibleTypes = [DatabaseType.struct, .map]
    |              |- warning: static property 'structCompatibleTypes' is not concurrency-safe because non-'Sendable' type '[DatabaseType]' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'structCompatibleTypes' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 84 |
 85 |   /// Properties associated with a struct type
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:39:15: note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
[341/352] Compiling DuckDB DatabaseError.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | /// The underlying database type of a DuckDB column
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:50:14: warning: static property 'boolean' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 48 | public extension DatabaseType {
 49 |   /// Boolean type castable to `Bool`
 50 |   static let boolean = DatabaseType(rawValue: DUCKDB_TYPE_BOOLEAN.rawValue)
    |              |- warning: static property 'boolean' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'boolean' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 51 |   /// Integer type castable to `Int8`
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:52:14: warning: static property 'tinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 50 |   static let boolean = DatabaseType(rawValue: DUCKDB_TYPE_BOOLEAN.rawValue)
 51 |   /// Integer type castable to `Int8`
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
    |              |- warning: static property 'tinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'tinyint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 53 |   /// Integer type castable to `Int16`
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:54:14: warning: static property 'smallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
 53 |   /// Integer type castable to `Int16`
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
    |              |- warning: static property 'smallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'smallint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 55 |   /// Integer type castable to `Int32`
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:56:14: warning: static property 'integer' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
 55 |   /// Integer type castable to `Int32`
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
    |              |- warning: static property 'integer' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'integer' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 57 |   /// Integer type castable to `Int64`
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:58:14: warning: static property 'bigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
 57 |   /// Integer type castable to `Int64`
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
    |              |- warning: static property 'bigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'bigint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 59 |   /// Integer type castable to `HugeInt`
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:60:14: warning: static property 'hugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
 59 |   /// Integer type castable to `HugeInt`
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
    |              |- warning: static property 'hugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'hugeint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 61 |   /// Integer type castable to `UHugeInt`
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:62:14: warning: static property 'uhugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
 61 |   /// Integer type castable to `UHugeInt`
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
    |              |- warning: static property 'uhugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uhugeint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 63 |   /// Unsigned integer type castable to `UInt8`
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:64:14: warning: static property 'utinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
 63 |   /// Unsigned integer type castable to `UInt8`
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
    |              |- warning: static property 'utinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'utinyint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 65 |   /// Unsigned integer type castable to `UInt16`
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:66:14: warning: static property 'usmallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
 65 |   /// Unsigned integer type castable to `UInt16`
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
    |              |- warning: static property 'usmallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'usmallint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 67 |   /// Unsigned integer type castable to `UInt32`
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:68:14: warning: static property 'uinteger' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
 67 |   /// Unsigned integer type castable to `UInt32`
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
    |              |- warning: static property 'uinteger' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uinteger' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 69 |   /// Unsigned integer type castable to `UInt64`
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:70:14: warning: static property 'ubigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
 69 |   /// Unsigned integer type castable to `UInt64`
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
    |              |- warning: static property 'ubigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'ubigint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 71 |   /// Floating point type castable to `Float`
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:72:14: warning: static property 'float' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
 71 |   /// Floating point type castable to `Float`
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
    |              |- warning: static property 'float' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'float' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 73 |   /// Floating point type castable to `Double`
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:74:14: warning: static property 'double' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
 73 |   /// Floating point type castable to `Double`
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
    |              |- warning: static property 'double' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'double' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 75 |   /// Timestamp type castable to `Timestamp`
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:76:14: warning: static property 'timestamp' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
 75 |   /// Timestamp type castable to `Timestamp`
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
    |              |- warning: static property 'timestamp' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestamp' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 77 |   /// Timestamp(TZ) type castable to `Timestamp`
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:78:14: warning: static property 'timestampTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
 77 |   /// Timestamp(TZ) type castable to `Timestamp`
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
    |              |- warning: static property 'timestampTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampTz' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 79 |   /// Date type castable to `Date`
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:80:14: warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
 79 |   /// Date type castable to `Date`
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
    |              |- warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'date' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 81 |   /// Time type castable to `Time`
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:82:14: warning: static property 'time' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
 81 |   /// Time type castable to `Time`
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
    |              |- warning: static property 'time' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'time' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 83 |   /// Time(TZ) type castable to `Time`
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:84:14: warning: static property 'timeTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
 83 |   /// Time(TZ) type castable to `Time`
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
    |              |- warning: static property 'timeTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timeTz' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 85 |   /// Interval type castable to `Interval`
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:86:14: warning: static property 'interval' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
 85 |   /// Interval type castable to `Interval`
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
    |              |- warning: static property 'interval' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'interval' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 87 |   /// String type castable to `String`
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:88:14: warning: static property 'varchar' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
 87 |   /// String type castable to `String`
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
    |              |- warning: static property 'varchar' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'varchar' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 89 |   /// Data type castable to `Data`
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:90:14: warning: static property 'blob' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
 89 |   /// Data type castable to `Data`
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
    |              |- warning: static property 'blob' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'blob' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 91 |   /// Decimal type castable to `Decimal`
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:92:14: warning: static property 'decimal' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
 91 |   /// Decimal type castable to `Decimal`
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
    |              |- warning: static property 'decimal' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'decimal' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 93 |   /// Timestamp type castable to `Timestamp`
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:94:14: warning: static property 'timestampS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
 93 |   /// Timestamp type castable to `Timestamp`
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
    |              |- warning: static property 'timestampS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 95 |   /// Timestamp type castable to `Timestamp`
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:96:14: warning: static property 'timestampMS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
 95 |   /// Timestamp type castable to `Timestamp`
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
    |              |- warning: static property 'timestampMS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampMS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 97 |   /// Timestamp type castable to `Timestamp`
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:98:14: warning: static property 'timestampNS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
 97 |   /// Timestamp type castable to `Timestamp`
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
    |              |- warning: static property 'timestampNS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampNS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 99 |   /// Enum type castable to suitable `Decodable` conforming types
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:100:14: warning: static property 'enum' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
 99 |   /// Enum type castable to suitable `Decodable` conforming types
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
    |              |- warning: static property 'enum' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'enum' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
101 |   /// Array type castable to suitable `Decodable` conforming types
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:102:14: warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
101 |   /// Array type castable to suitable `Decodable` conforming types
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
    |              |- warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'list' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
103 |   /// Struct type castable to suitable `Decodable` conforming types
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:104:14: warning: static property 'struct' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
103 |   /// Struct type castable to suitable `Decodable` conforming types
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
    |              |- warning: static property 'struct' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'struct' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
105 |   /// Dictionary type castable to suitable `Decodable` conforming types
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:106:14: warning: static property 'map' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
105 |   /// Dictionary type castable to suitable `Decodable` conforming types
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
    |              |- warning: static property 'map' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'map' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
107 |   /// Enum type castable to suitable `Decodable` conforming types
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:108:14: warning: static property 'union' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
107 |   /// Enum type castable to suitable `Decodable` conforming types
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
    |              |- warning: static property 'union' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'union' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
109 |   /// UUID type castable to `UUID`
110 |   static let uuid = DatabaseType(rawValue: DUCKDB_TYPE_UUID.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:110:14: warning: static property 'uuid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
109 |   /// UUID type castable to `UUID`
110 |   static let uuid = DatabaseType(rawValue: DUCKDB_TYPE_UUID.rawValue)
    |              |- warning: static property 'uuid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uuid' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
111 | }
112 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:116:14: warning: static property 'invalid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
114 |
115 | extension DatabaseType {
116 |   static let invalid = DatabaseType(rawValue: DUCKDB_TYPE_INVALID.rawValue)
    |              |- warning: static property 'invalid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'invalid' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
117 | }
118 |
[342/352] Compiling DuckDB DatabaseType.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | /// The underlying database type of a DuckDB column
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:50:14: warning: static property 'boolean' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 48 | public extension DatabaseType {
 49 |   /// Boolean type castable to `Bool`
 50 |   static let boolean = DatabaseType(rawValue: DUCKDB_TYPE_BOOLEAN.rawValue)
    |              |- warning: static property 'boolean' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'boolean' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 51 |   /// Integer type castable to `Int8`
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:52:14: warning: static property 'tinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 50 |   static let boolean = DatabaseType(rawValue: DUCKDB_TYPE_BOOLEAN.rawValue)
 51 |   /// Integer type castable to `Int8`
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
    |              |- warning: static property 'tinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'tinyint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 53 |   /// Integer type castable to `Int16`
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:54:14: warning: static property 'smallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
 53 |   /// Integer type castable to `Int16`
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
    |              |- warning: static property 'smallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'smallint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 55 |   /// Integer type castable to `Int32`
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:56:14: warning: static property 'integer' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
 55 |   /// Integer type castable to `Int32`
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
    |              |- warning: static property 'integer' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'integer' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 57 |   /// Integer type castable to `Int64`
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:58:14: warning: static property 'bigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
 57 |   /// Integer type castable to `Int64`
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
    |              |- warning: static property 'bigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'bigint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 59 |   /// Integer type castable to `HugeInt`
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:60:14: warning: static property 'hugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
 59 |   /// Integer type castable to `HugeInt`
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
    |              |- warning: static property 'hugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'hugeint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 61 |   /// Integer type castable to `UHugeInt`
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:62:14: warning: static property 'uhugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
 61 |   /// Integer type castable to `UHugeInt`
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
    |              |- warning: static property 'uhugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uhugeint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 63 |   /// Unsigned integer type castable to `UInt8`
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:64:14: warning: static property 'utinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
 63 |   /// Unsigned integer type castable to `UInt8`
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
    |              |- warning: static property 'utinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'utinyint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 65 |   /// Unsigned integer type castable to `UInt16`
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:66:14: warning: static property 'usmallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
 65 |   /// Unsigned integer type castable to `UInt16`
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
    |              |- warning: static property 'usmallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'usmallint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 67 |   /// Unsigned integer type castable to `UInt32`
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:68:14: warning: static property 'uinteger' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
 67 |   /// Unsigned integer type castable to `UInt32`
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
    |              |- warning: static property 'uinteger' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uinteger' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 69 |   /// Unsigned integer type castable to `UInt64`
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:70:14: warning: static property 'ubigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
 69 |   /// Unsigned integer type castable to `UInt64`
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
    |              |- warning: static property 'ubigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'ubigint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 71 |   /// Floating point type castable to `Float`
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:72:14: warning: static property 'float' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
 71 |   /// Floating point type castable to `Float`
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
    |              |- warning: static property 'float' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'float' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 73 |   /// Floating point type castable to `Double`
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:74:14: warning: static property 'double' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
 73 |   /// Floating point type castable to `Double`
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
    |              |- warning: static property 'double' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'double' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 75 |   /// Timestamp type castable to `Timestamp`
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:76:14: warning: static property 'timestamp' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
 75 |   /// Timestamp type castable to `Timestamp`
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
    |              |- warning: static property 'timestamp' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestamp' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 77 |   /// Timestamp(TZ) type castable to `Timestamp`
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:78:14: warning: static property 'timestampTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
 77 |   /// Timestamp(TZ) type castable to `Timestamp`
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
    |              |- warning: static property 'timestampTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampTz' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 79 |   /// Date type castable to `Date`
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:80:14: warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
 79 |   /// Date type castable to `Date`
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
    |              |- warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'date' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 81 |   /// Time type castable to `Time`
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:82:14: warning: static property 'time' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
 81 |   /// Time type castable to `Time`
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
    |              |- warning: static property 'time' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'time' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 83 |   /// Time(TZ) type castable to `Time`
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:84:14: warning: static property 'timeTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
 83 |   /// Time(TZ) type castable to `Time`
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
    |              |- warning: static property 'timeTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timeTz' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 85 |   /// Interval type castable to `Interval`
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:86:14: warning: static property 'interval' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
 85 |   /// Interval type castable to `Interval`
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
    |              |- warning: static property 'interval' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'interval' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 87 |   /// String type castable to `String`
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:88:14: warning: static property 'varchar' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
 87 |   /// String type castable to `String`
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
    |              |- warning: static property 'varchar' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'varchar' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 89 |   /// Data type castable to `Data`
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:90:14: warning: static property 'blob' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
 89 |   /// Data type castable to `Data`
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
    |              |- warning: static property 'blob' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'blob' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 91 |   /// Decimal type castable to `Decimal`
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:92:14: warning: static property 'decimal' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
 91 |   /// Decimal type castable to `Decimal`
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
    |              |- warning: static property 'decimal' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'decimal' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 93 |   /// Timestamp type castable to `Timestamp`
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:94:14: warning: static property 'timestampS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
 93 |   /// Timestamp type castable to `Timestamp`
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
    |              |- warning: static property 'timestampS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 95 |   /// Timestamp type castable to `Timestamp`
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:96:14: warning: static property 'timestampMS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
 95 |   /// Timestamp type castable to `Timestamp`
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
    |              |- warning: static property 'timestampMS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampMS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 97 |   /// Timestamp type castable to `Timestamp`
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:98:14: warning: static property 'timestampNS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
 97 |   /// Timestamp type castable to `Timestamp`
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
    |              |- warning: static property 'timestampNS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampNS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 99 |   /// Enum type castable to suitable `Decodable` conforming types
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:100:14: warning: static property 'enum' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
 99 |   /// Enum type castable to suitable `Decodable` conforming types
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
    |              |- warning: static property 'enum' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'enum' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
101 |   /// Array type castable to suitable `Decodable` conforming types
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:102:14: warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
101 |   /// Array type castable to suitable `Decodable` conforming types
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
    |              |- warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'list' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
103 |   /// Struct type castable to suitable `Decodable` conforming types
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:104:14: warning: static property 'struct' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
103 |   /// Struct type castable to suitable `Decodable` conforming types
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
    |              |- warning: static property 'struct' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'struct' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
105 |   /// Dictionary type castable to suitable `Decodable` conforming types
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:106:14: warning: static property 'map' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
105 |   /// Dictionary type castable to suitable `Decodable` conforming types
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
    |              |- warning: static property 'map' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'map' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
107 |   /// Enum type castable to suitable `Decodable` conforming types
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:108:14: warning: static property 'union' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
107 |   /// Enum type castable to suitable `Decodable` conforming types
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
    |              |- warning: static property 'union' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'union' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
109 |   /// UUID type castable to `UUID`
110 |   static let uuid = DatabaseType(rawValue: DUCKDB_TYPE_UUID.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:110:14: warning: static property 'uuid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
109 |   /// UUID type castable to `UUID`
110 |   static let uuid = DatabaseType(rawValue: DUCKDB_TYPE_UUID.rawValue)
    |              |- warning: static property 'uuid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uuid' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
111 | }
112 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:116:14: warning: static property 'invalid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
114 |
115 | extension DatabaseType {
116 |   static let invalid = DatabaseType(rawValue: DUCKDB_TYPE_INVALID.rawValue)
    |              |- warning: static property 'invalid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'invalid' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
117 | }
118 |
[343/352] Compiling DuckDB Column+TabularData.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | /// The underlying database type of a DuckDB column
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:50:14: warning: static property 'boolean' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 48 | public extension DatabaseType {
 49 |   /// Boolean type castable to `Bool`
 50 |   static let boolean = DatabaseType(rawValue: DUCKDB_TYPE_BOOLEAN.rawValue)
    |              |- warning: static property 'boolean' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'boolean' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 51 |   /// Integer type castable to `Int8`
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:52:14: warning: static property 'tinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 50 |   static let boolean = DatabaseType(rawValue: DUCKDB_TYPE_BOOLEAN.rawValue)
 51 |   /// Integer type castable to `Int8`
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
    |              |- warning: static property 'tinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'tinyint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 53 |   /// Integer type castable to `Int16`
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:54:14: warning: static property 'smallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 52 |   static let tinyint = DatabaseType(rawValue: DUCKDB_TYPE_TINYINT.rawValue)
 53 |   /// Integer type castable to `Int16`
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
    |              |- warning: static property 'smallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'smallint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 55 |   /// Integer type castable to `Int32`
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:56:14: warning: static property 'integer' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 54 |   static let smallint = DatabaseType(rawValue: DUCKDB_TYPE_SMALLINT.rawValue)
 55 |   /// Integer type castable to `Int32`
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
    |              |- warning: static property 'integer' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'integer' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 57 |   /// Integer type castable to `Int64`
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:58:14: warning: static property 'bigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 56 |   static let integer = DatabaseType(rawValue: DUCKDB_TYPE_INTEGER.rawValue)
 57 |   /// Integer type castable to `Int64`
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
    |              |- warning: static property 'bigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'bigint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 59 |   /// Integer type castable to `HugeInt`
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:60:14: warning: static property 'hugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 58 |   static let bigint = DatabaseType(rawValue: DUCKDB_TYPE_BIGINT.rawValue)
 59 |   /// Integer type castable to `HugeInt`
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
    |              |- warning: static property 'hugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'hugeint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 61 |   /// Integer type castable to `UHugeInt`
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:62:14: warning: static property 'uhugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 60 |   static let hugeint = DatabaseType(rawValue: DUCKDB_TYPE_HUGEINT.rawValue)
 61 |   /// Integer type castable to `UHugeInt`
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
    |              |- warning: static property 'uhugeint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uhugeint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 63 |   /// Unsigned integer type castable to `UInt8`
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:64:14: warning: static property 'utinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 62 |   static let uhugeint = DatabaseType(rawValue: DUCKDB_TYPE_UHUGEINT.rawValue)
 63 |   /// Unsigned integer type castable to `UInt8`
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
    |              |- warning: static property 'utinyint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'utinyint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 65 |   /// Unsigned integer type castable to `UInt16`
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:66:14: warning: static property 'usmallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 64 |   static let utinyint = DatabaseType(rawValue: DUCKDB_TYPE_UTINYINT.rawValue)
 65 |   /// Unsigned integer type castable to `UInt16`
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
    |              |- warning: static property 'usmallint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'usmallint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 67 |   /// Unsigned integer type castable to `UInt32`
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:68:14: warning: static property 'uinteger' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 66 |   static let usmallint = DatabaseType(rawValue: DUCKDB_TYPE_USMALLINT.rawValue)
 67 |   /// Unsigned integer type castable to `UInt32`
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
    |              |- warning: static property 'uinteger' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uinteger' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 69 |   /// Unsigned integer type castable to `UInt64`
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:70:14: warning: static property 'ubigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 68 |   static let uinteger = DatabaseType(rawValue: DUCKDB_TYPE_UINTEGER.rawValue)
 69 |   /// Unsigned integer type castable to `UInt64`
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
    |              |- warning: static property 'ubigint' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'ubigint' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 71 |   /// Floating point type castable to `Float`
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:72:14: warning: static property 'float' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 70 |   static let ubigint = DatabaseType(rawValue: DUCKDB_TYPE_UBIGINT.rawValue)
 71 |   /// Floating point type castable to `Float`
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
    |              |- warning: static property 'float' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'float' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 73 |   /// Floating point type castable to `Double`
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:74:14: warning: static property 'double' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 72 |   static let float = DatabaseType(rawValue: DUCKDB_TYPE_FLOAT.rawValue)
 73 |   /// Floating point type castable to `Double`
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
    |              |- warning: static property 'double' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'double' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 75 |   /// Timestamp type castable to `Timestamp`
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:76:14: warning: static property 'timestamp' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 74 |   static let double = DatabaseType(rawValue: DUCKDB_TYPE_DOUBLE.rawValue)
 75 |   /// Timestamp type castable to `Timestamp`
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
    |              |- warning: static property 'timestamp' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestamp' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 77 |   /// Timestamp(TZ) type castable to `Timestamp`
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:78:14: warning: static property 'timestampTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 76 |   static let timestamp = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP.rawValue)
 77 |   /// Timestamp(TZ) type castable to `Timestamp`
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
    |              |- warning: static property 'timestampTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampTz' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 79 |   /// Date type castable to `Date`
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:80:14: warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 78 |   static let timestampTz = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_TZ.rawValue)
 79 |   /// Date type castable to `Date`
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
    |              |- warning: static property 'date' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'date' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 81 |   /// Time type castable to `Time`
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:82:14: warning: static property 'time' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 80 |   static let date = DatabaseType(rawValue: DUCKDB_TYPE_DATE.rawValue)
 81 |   /// Time type castable to `Time`
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
    |              |- warning: static property 'time' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'time' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 83 |   /// Time(TZ) type castable to `Time`
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:84:14: warning: static property 'timeTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 82 |   static let time = DatabaseType(rawValue: DUCKDB_TYPE_TIME.rawValue)
 83 |   /// Time(TZ) type castable to `Time`
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
    |              |- warning: static property 'timeTz' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timeTz' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 85 |   /// Interval type castable to `Interval`
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:86:14: warning: static property 'interval' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 84 |   static let timeTz = DatabaseType(rawValue: DUCKDB_TYPE_TIME_TZ.rawValue)
 85 |   /// Interval type castable to `Interval`
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
    |              |- warning: static property 'interval' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'interval' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 87 |   /// String type castable to `String`
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:88:14: warning: static property 'varchar' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 86 |   static let interval = DatabaseType(rawValue: DUCKDB_TYPE_INTERVAL.rawValue)
 87 |   /// String type castable to `String`
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
    |              |- warning: static property 'varchar' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'varchar' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 89 |   /// Data type castable to `Data`
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:90:14: warning: static property 'blob' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 88 |   static let varchar = DatabaseType(rawValue: DUCKDB_TYPE_VARCHAR.rawValue)
 89 |   /// Data type castable to `Data`
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
    |              |- warning: static property 'blob' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'blob' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 91 |   /// Decimal type castable to `Decimal`
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:92:14: warning: static property 'decimal' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 90 |   static let blob = DatabaseType(rawValue: DUCKDB_TYPE_BLOB.rawValue)
 91 |   /// Decimal type castable to `Decimal`
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
    |              |- warning: static property 'decimal' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'decimal' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 93 |   /// Timestamp type castable to `Timestamp`
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:94:14: warning: static property 'timestampS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 92 |   static let decimal = DatabaseType(rawValue: DUCKDB_TYPE_DECIMAL.rawValue)
 93 |   /// Timestamp type castable to `Timestamp`
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
    |              |- warning: static property 'timestampS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 95 |   /// Timestamp type castable to `Timestamp`
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:96:14: warning: static property 'timestampMS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 94 |   static let timestampS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_S.rawValue)
 95 |   /// Timestamp type castable to `Timestamp`
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
    |              |- warning: static property 'timestampMS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampMS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 97 |   /// Timestamp type castable to `Timestamp`
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:98:14: warning: static property 'timestampNS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 96 |   static let timestampMS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_MS.rawValue)
 97 |   /// Timestamp type castable to `Timestamp`
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
    |              |- warning: static property 'timestampNS' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'timestampNS' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 99 |   /// Enum type castable to suitable `Decodable` conforming types
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:100:14: warning: static property 'enum' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
 98 |   static let timestampNS = DatabaseType(rawValue: DUCKDB_TYPE_TIMESTAMP_NS.rawValue)
 99 |   /// Enum type castable to suitable `Decodable` conforming types
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
    |              |- warning: static property 'enum' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'enum' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
101 |   /// Array type castable to suitable `Decodable` conforming types
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:102:14: warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
100 |   static let `enum` = DatabaseType(rawValue: DUCKDB_TYPE_ENUM.rawValue)
101 |   /// Array type castable to suitable `Decodable` conforming types
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
    |              |- warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'list' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
103 |   /// Struct type castable to suitable `Decodable` conforming types
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:104:14: warning: static property 'struct' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
102 |   static let list = DatabaseType(rawValue: DUCKDB_TYPE_LIST.rawValue)
103 |   /// Struct type castable to suitable `Decodable` conforming types
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
    |              |- warning: static property 'struct' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'struct' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
105 |   /// Dictionary type castable to suitable `Decodable` conforming types
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:106:14: warning: static property 'map' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
104 |   static let `struct` = DatabaseType(rawValue: DUCKDB_TYPE_STRUCT.rawValue)
105 |   /// Dictionary type castable to suitable `Decodable` conforming types
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
    |              |- warning: static property 'map' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'map' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
107 |   /// Enum type castable to suitable `Decodable` conforming types
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:108:14: warning: static property 'union' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
106 |   static let map = DatabaseType(rawValue: DUCKDB_TYPE_MAP.rawValue)
107 |   /// Enum type castable to suitable `Decodable` conforming types
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
    |              |- warning: static property 'union' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'union' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
109 |   /// UUID type castable to `UUID`
110 |   static let uuid = DatabaseType(rawValue: DUCKDB_TYPE_UUID.rawValue)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:110:14: warning: static property 'uuid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
108 |   static let union = DatabaseType(rawValue: DUCKDB_TYPE_UNION.rawValue)
109 |   /// UUID type castable to `UUID`
110 |   static let uuid = DatabaseType(rawValue: DUCKDB_TYPE_UUID.rawValue)
    |              |- warning: static property 'uuid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'uuid' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
111 | }
112 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/DatabaseType.swift:116:14: warning: static property 'invalid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
 37 | /// define database types as arbitrary structs (`ROW(i INTEGER, j VARCHAR)`),
 38 | /// which can be cast to their `Decodable` matching Swift type in the same way.
 39 | public struct DatabaseType: RawRepresentable, Hashable, Equatable {
    |               `- note: consider making struct 'DatabaseType' conform to the 'Sendable' protocol
 40 |   public let rawValue: UInt32
 41 |   public init(rawValue: UInt32) {
    :
114 |
115 | extension DatabaseType {
116 |   static let invalid = DatabaseType(rawValue: DUCKDB_TYPE_INVALID.rawValue)
    |              |- warning: static property 'invalid' is not concurrency-safe because non-'Sendable' type 'DatabaseType' may have shared mutable state; this is an error in the Swift 6 language mode
    |              |- note: add '@MainActor' to make static property 'invalid' part of global actor 'MainActor'
    |              `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
117 | }
118 |
[344/352] Compiling DuckDB Date+Foundation.swift
[345/352] Compiling DuckDB Decimal+IntHuge.swift
[346/352] Compiling DuckDB Time+Foundation.swift
[347/352] Compiling DuckDB Configuration.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Configuration.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | public extension Database {
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Connection.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | /// An object representing a connection to a DuckDB database
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Database.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Connection.swift:51:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'Connection' has non-sendable type 'UnsafeMutablePointer<duckdb_connection?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_connection>>>'); this is an error in the Swift 6 language mode
 49 |
 50 |   private let database: Database
 51 |   private let ptr = UnsafeMutablePointer<duckdb_connection?>.allocate(capacity: 1)
    |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'Connection' has non-sendable type 'UnsafeMutablePointer<duckdb_connection?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_connection>>>'); this is an error in the Swift 6 language mode
 52 |
 53 |   /// Creates a new connection
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Database.swift:66:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'Database' has non-sendable type 'UnsafeMutablePointer<duckdb_database?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_database>>>'); this is an error in the Swift 6 language mode
 64 |   }
 65 |
 66 |   private let ptr = UnsafeMutablePointer<duckdb_database?>.allocate(capacity: 1)
    |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'Database' has non-sendable type 'UnsafeMutablePointer<duckdb_database?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_database>>>'); this is an error in the Swift 6 language mode
 67 |
 68 |   /// Creates a Duck DB database
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
[348/352] Compiling DuckDB Connection.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Configuration.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | public extension Database {
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Connection.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | /// An object representing a connection to a DuckDB database
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Database.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Connection.swift:51:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'Connection' has non-sendable type 'UnsafeMutablePointer<duckdb_connection?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_connection>>>'); this is an error in the Swift 6 language mode
 49 |
 50 |   private let database: Database
 51 |   private let ptr = UnsafeMutablePointer<duckdb_connection?>.allocate(capacity: 1)
    |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'Connection' has non-sendable type 'UnsafeMutablePointer<duckdb_connection?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_connection>>>'); this is an error in the Swift 6 language mode
 52 |
 53 |   /// Creates a new connection
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Database.swift:66:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'Database' has non-sendable type 'UnsafeMutablePointer<duckdb_database?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_database>>>'); this is an error in the Swift 6 language mode
 64 |   }
 65 |
 66 |   private let ptr = UnsafeMutablePointer<duckdb_database?>.allocate(capacity: 1)
    |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'Database' has non-sendable type 'UnsafeMutablePointer<duckdb_database?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_database>>>'); this is an error in the Swift 6 language mode
 67 |
 68 |   /// Creates a Duck DB database
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
[349/352] Compiling DuckDB Database.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Configuration.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | public extension Database {
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Connection.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 |
 27 | /// An object representing a connection to a DuckDB database
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Database.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Connection.swift:51:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'Connection' has non-sendable type 'UnsafeMutablePointer<duckdb_connection?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_connection>>>'); this is an error in the Swift 6 language mode
 49 |
 50 |   private let database: Database
 51 |   private let ptr = UnsafeMutablePointer<duckdb_connection?>.allocate(capacity: 1)
    |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'Connection' has non-sendable type 'UnsafeMutablePointer<duckdb_connection?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_connection>>>'); this is an error in the Swift 6 language mode
 52 |
 53 |   /// Creates a new connection
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Database.swift:66:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'Database' has non-sendable type 'UnsafeMutablePointer<duckdb_database?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_database>>>'); this is an error in the Swift 6 language mode
 64 |   }
 65 |
 66 |   private let ptr = UnsafeMutablePointer<duckdb_database?>.allocate(capacity: 1)
    |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'Database' has non-sendable type 'UnsafeMutablePointer<duckdb_database?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_database>>>'); this is an error in the Swift 6 language mode
 67 |
 68 |   /// Creates a Duck DB database
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
[350/352] Compiling DuckDB Timestamp+Foundation.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/CTypeUtilities.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/DataChunk.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
23 | //  IN THE SOFTWARE.
24 |
25 | @_implementationOnly import Cduckdb
   |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
26 | import Foundation
27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/DataChunk.swift:33:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'DataChunk' has non-sendable type 'UnsafeMutablePointer<duckdb_data_chunk?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_data_chunk>>>'); this is an error in the Swift 6 language mode
31 |   var columnCount: DBInt { duckdb_data_chunk_get_column_count(ptr.pointee) }
32 |
33 |   private let ptr = UnsafeMutablePointer<duckdb_data_chunk?>.allocate(capacity: 1)
   |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'DataChunk' has non-sendable type 'UnsafeMutablePointer<duckdb_data_chunk?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_data_chunk>>>'); this is an error in the Swift 6 language mode
34 |
35 |   init(cresult: duckdb_result, index: DBInt) {
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
[351/352] Compiling DuckDB CTypeUtilities.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/CTypeUtilities.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/DataChunk.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
23 | //  IN THE SOFTWARE.
24 |
25 | @_implementationOnly import Cduckdb
   |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
26 | import Foundation
27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/DataChunk.swift:33:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'DataChunk' has non-sendable type 'UnsafeMutablePointer<duckdb_data_chunk?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_data_chunk>>>'); this is an error in the Swift 6 language mode
31 |   var columnCount: DBInt { duckdb_data_chunk_get_column_count(ptr.pointee) }
32 |
33 |   private let ptr = UnsafeMutablePointer<duckdb_data_chunk?>.allocate(capacity: 1)
   |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'DataChunk' has non-sendable type 'UnsafeMutablePointer<duckdb_data_chunk?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_data_chunk>>>'); this is an error in the Swift 6 language mode
34 |
35 |   init(cresult: duckdb_result, index: DBInt) {
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
[352/352] Compiling DuckDB DataChunk.swift
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/CTypeUtilities.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 23 | //  IN THE SOFTWARE.
 24 |
 25 | @_implementationOnly import Cduckdb
    |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
 26 | import Foundation
 27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/DataChunk.swift:25:22: warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
23 | //  IN THE SOFTWARE.
24 |
25 | @_implementationOnly import Cduckdb
   |                      `- warning: using '@_implementationOnly' without enabling library evolution for 'DuckDB' may lead to instability during execution
26 | import Foundation
27 |
/Users/admin/builder/spi-builder-workspace/Sources/DuckDB/Internal/DataChunk.swift:33:15: warning: stored property 'ptr' of 'Sendable'-conforming class 'DataChunk' has non-sendable type 'UnsafeMutablePointer<duckdb_data_chunk?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_data_chunk>>>'); this is an error in the Swift 6 language mode
31 |   var columnCount: DBInt { duckdb_data_chunk_get_column_count(ptr.pointee) }
32 |
33 |   private let ptr = UnsafeMutablePointer<duckdb_data_chunk?>.allocate(capacity: 1)
   |               `- warning: stored property 'ptr' of 'Sendable'-conforming class 'DataChunk' has non-sendable type 'UnsafeMutablePointer<duckdb_data_chunk?>' (aka 'UnsafeMutablePointer<Optional<UnsafeMutablePointer<_duckdb_data_chunk>>>'); this is an error in the Swift 6 language mode
34 |
35 |   init(cresult: duckdb_result, index: DBInt) {
Swift.UnsafeMutablePointer:1:23: note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutablePointer<Pointee> : Copyable where Pointee : ~Copyable {
  |                       `- note: generic struct 'UnsafeMutablePointer' does not conform to the 'Sendable' protocol
2 |     public let _rawValue: Builtin.RawPointer
3 |     public init(_ _rawValue: Builtin.RawPointer)
Build complete! (77.19s)
Build complete.
{
  "cxx_language_standard" : "c++11",
  "dependencies" : [
  ],
  "manifest_display_name" : "DuckDB",
  "name" : "DuckDB",
  "path" : "/Users/admin/builder/spi-builder-workspace",
  "platforms" : [
  ],
  "products" : [
    {
      "name" : "DuckDB",
      "targets" : [
        "DuckDB"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "DuckDBTests",
      "module_type" : "SwiftTarget",
      "name" : "DuckDBTests",
      "path" : "Tests/DuckDBTests",
      "sources" : [
        "AppenderTests.swift",
        "CodingUserInfoKeysTests.swift",
        "DatabaseTests.swift",
        "DecimalUtilityTests.swift",
        "ExtensionTests.swift",
        "LogicalTypeTests.swift",
        "PreparedStatementTests.swift",
        "TypeConversionTests.swift"
      ],
      "target_dependencies" : [
        "DuckDB"
      ],
      "type" : "test"
    },
    {
      "c99name" : "DuckDB",
      "module_type" : "SwiftTarget",
      "name" : "DuckDB",
      "path" : "Sources/DuckDB",
      "product_memberships" : [
        "DuckDB"
      ],
      "sources" : [
        "Appender.swift",
        "CodingUserInfoKeys.swift",
        "Column.swift",
        "Configuration.swift",
        "Connection.swift",
        "Database.swift",
        "DatabaseError.swift",
        "DatabaseType.swift",
        "Extensions/Column+TabularData.swift",
        "Extensions/Date+Foundation.swift",
        "Extensions/Decimal+IntHuge.swift",
        "Extensions/Time+Foundation.swift",
        "Extensions/Timestamp+Foundation.swift",
        "Internal/CTypeUtilities.swift",
        "Internal/DataChunk.swift",
        "Internal/DecimalStorageType.swift",
        "Internal/Optional+CString.swift",
        "Internal/PrimitiveDatabaseValue.swift",
        "Internal/Vector.swift",
        "Internal/VectorElementDecoder.swift",
        "LogicalType.swift",
        "PreparedStatement.swift",
        "ResultSet.swift",
        "Types/Date.swift",
        "Types/IntHuge.swift",
        "Types/Interval.swift",
        "Types/Time.swift",
        "Types/Timestamp.swift"
      ],
      "target_dependencies" : [
        "Cduckdb"
      ],
      "type" : "library"
    },
    {
      "c99name" : "Cduckdb",
      "module_type" : "ClangTarget",
      "name" : "Cduckdb",
      "path" : "Sources/Cduckdb",
      "product_memberships" : [
        "DuckDB"
      ],
      "sources" : [
        "duckdb/extension/icu/icu-dateadd.cpp",
        "duckdb/extension/icu/icu-datefunc.cpp",
        "duckdb/extension/icu/icu-datepart.cpp",
        "duckdb/extension/icu/icu-datesub.cpp",
        "duckdb/extension/icu/icu-datetrunc.cpp",
        "duckdb/extension/icu/icu-list-range.cpp",
        "duckdb/extension/icu/icu-makedate.cpp",
        "duckdb/extension/icu/icu-strptime.cpp",
        "duckdb/extension/icu/icu-table-range.cpp",
        "duckdb/extension/icu/icu-timebucket.cpp",
        "duckdb/extension/icu/icu-timezone.cpp",
        "duckdb/extension/icu/icu_extension.cpp",
        "duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp",
        "duckdb/extension/json/buffered_json_reader.cpp",
        "duckdb/extension/json/json_common.cpp",
        "duckdb/extension/json/json_deserializer.cpp",
        "duckdb/extension/json/json_enums.cpp",
        "duckdb/extension/json/json_extension.cpp",
        "duckdb/extension/json/json_functions.cpp",
        "duckdb/extension/json/json_scan.cpp",
        "duckdb/extension/json/json_serializer.cpp",
        "duckdb/extension/json/serialize_json.cpp",
        "duckdb/extension/parquet/column_reader.cpp",
        "duckdb/extension/parquet/column_writer.cpp",
        "duckdb/extension/parquet/geo_parquet.cpp",
        "duckdb/extension/parquet/parquet_crypto.cpp",
        "duckdb/extension/parquet/parquet_extension.cpp",
        "duckdb/extension/parquet/parquet_metadata.cpp",
        "duckdb/extension/parquet/parquet_reader.cpp",
        "duckdb/extension/parquet/parquet_statistics.cpp",
        "duckdb/extension/parquet/parquet_timestamp.cpp",
        "duckdb/extension/parquet/parquet_writer.cpp",
        "duckdb/extension/parquet/serialize_parquet.cpp",
        "duckdb/extension/parquet/zstd_file_system.cpp",
        "duckdb/src/common/vector_operations/boolean_operators.cpp",
        "duckdb/src/common/vector_operations/comparison_operators.cpp",
        "duckdb/src/common/vector_operations/generators.cpp",
        "duckdb/src/common/vector_operations/is_distinct_from.cpp",
        "duckdb/src/common/vector_operations/null_operations.cpp",
        "duckdb/src/common/vector_operations/numeric_inplace_operators.cpp",
        "duckdb/src/common/vector_operations/vector_cast.cpp",
        "duckdb/src/common/vector_operations/vector_copy.cpp",
        "duckdb/src/common/vector_operations/vector_hash.cpp",
        "duckdb/src/common/vector_operations/vector_storage.cpp",
        "duckdb/src/verification/copied_statement_verifier.cpp",
        "duckdb/src/verification/deserialized_statement_verifier.cpp",
        "duckdb/src/verification/external_statement_verifier.cpp",
        "duckdb/src/verification/fetch_row_verifier.cpp",
        "duckdb/src/verification/no_operator_caching_verifier.cpp",
        "duckdb/src/verification/parsed_statement_verifier.cpp",
        "duckdb/src/verification/prepared_statement_verifier.cpp",
        "duckdb/src/verification/statement_verifier.cpp",
        "duckdb/src/verification/unoptimized_statement_verifier.cpp",
        "duckdb/third_party/brotli/common/constants.cpp",
        "duckdb/third_party/brotli/common/context.cpp",
        "duckdb/third_party/brotli/common/dictionary.cpp",
        "duckdb/third_party/brotli/common/platform.cpp",
        "duckdb/third_party/brotli/common/shared_dictionary.cpp",
        "duckdb/third_party/brotli/common/transform.cpp",
        "duckdb/third_party/brotli/dec/bit_reader.cpp",
        "duckdb/third_party/brotli/dec/decode.cpp",
        "duckdb/third_party/brotli/dec/huffman.cpp",
        "duckdb/third_party/brotli/dec/state.cpp",
        "duckdb/third_party/brotli/enc/backward_references.cpp",
        "duckdb/third_party/brotli/enc/backward_references_hq.cpp",
        "duckdb/third_party/brotli/enc/bit_cost.cpp",
        "duckdb/third_party/brotli/enc/block_splitter.cpp",
        "duckdb/third_party/brotli/enc/brotli_bit_stream.cpp",
        "duckdb/third_party/brotli/enc/cluster.cpp",
        "duckdb/third_party/brotli/enc/command.cpp",
        "duckdb/third_party/brotli/enc/compound_dictionary.cpp",
        "duckdb/third_party/brotli/enc/compress_fragment.cpp",
        "duckdb/third_party/brotli/enc/compress_fragment_two_pass.cpp",
        "duckdb/third_party/brotli/enc/dictionary_hash.cpp",
        "duckdb/third_party/brotli/enc/encode.cpp",
        "duckdb/third_party/brotli/enc/encoder_dict.cpp",
        "duckdb/third_party/brotli/enc/entropy_encode.cpp",
        "duckdb/third_party/brotli/enc/fast_log.cpp",
        "duckdb/third_party/brotli/enc/histogram.cpp",
        "duckdb/third_party/brotli/enc/literal_cost.cpp",
        "duckdb/third_party/brotli/enc/memory.cpp",
        "duckdb/third_party/brotli/enc/metablock.cpp",
        "duckdb/third_party/brotli/enc/static_dict.cpp",
        "duckdb/third_party/brotli/enc/utf8_util.cpp",
        "duckdb/third_party/fastpforlib/bitpacking.cpp",
        "duckdb/third_party/fmt/format.cc",
        "duckdb/third_party/fsst/libfsst.cpp",
        "duckdb/third_party/hyperloglog/hyperloglog.cpp",
        "duckdb/third_party/hyperloglog/sds.cpp",
        "duckdb/third_party/libpg_query/pg_functions.cpp",
        "duckdb/third_party/libpg_query/postgres_parser.cpp",
        "duckdb/third_party/libpg_query/src_backend_nodes_list.cpp",
        "duckdb/third_party/libpg_query/src_backend_nodes_makefuncs.cpp",
        "duckdb/third_party/libpg_query/src_backend_nodes_value.cpp",
        "duckdb/third_party/libpg_query/src_backend_parser_gram.cpp",
        "duckdb/third_party/libpg_query/src_backend_parser_parser.cpp",
        "duckdb/third_party/libpg_query/src_backend_parser_scan.cpp",
        "duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp",
        "duckdb/third_party/libpg_query/src_common_keywords.cpp",
        "duckdb/third_party/lz4/lz4.cpp",
        "duckdb/third_party/mbedtls/library/aes.cpp",
        "duckdb/third_party/mbedtls/library/aria.cpp",
        "duckdb/third_party/mbedtls/library/asn1parse.cpp",
        "duckdb/third_party/mbedtls/library/base64.cpp",
        "duckdb/third_party/mbedtls/library/bignum.cpp",
        "duckdb/third_party/mbedtls/library/camellia.cpp",
        "duckdb/third_party/mbedtls/library/cipher.cpp",
        "duckdb/third_party/mbedtls/library/cipher_wrap.cpp",
        "duckdb/third_party/mbedtls/library/constant_time.cpp",
        "duckdb/third_party/mbedtls/library/entropy.cpp",
        "duckdb/third_party/mbedtls/library/entropy_poll.cpp",
        "duckdb/third_party/mbedtls/library/gcm.cpp",
        "duckdb/third_party/mbedtls/library/md.cpp",
        "duckdb/third_party/mbedtls/library/oid.cpp",
        "duckdb/third_party/mbedtls/library/pem.cpp",
        "duckdb/third_party/mbedtls/library/pk.cpp",
        "duckdb/third_party/mbedtls/library/pk_wrap.cpp",
        "duckdb/third_party/mbedtls/library/pkparse.cpp",
        "duckdb/third_party/mbedtls/library/platform_util.cpp",
        "duckdb/third_party/mbedtls/library/rsa.cpp",
        "duckdb/third_party/mbedtls/library/rsa_alt_helpers.cpp",
        "duckdb/third_party/mbedtls/library/sha1.cpp",
        "duckdb/third_party/mbedtls/library/sha256.cpp",
        "duckdb/third_party/mbedtls/library/sha512.cpp",
        "duckdb/third_party/mbedtls/mbedtls_wrapper.cpp",
        "duckdb/third_party/miniz/miniz.cpp",
        "duckdb/third_party/parquet/parquet_constants.cpp",
        "duckdb/third_party/parquet/parquet_types.cpp",
        "duckdb/third_party/re2/re2/bitmap256.cc",
        "duckdb/third_party/re2/re2/bitstate.cc",
        "duckdb/third_party/re2/re2/compile.cc",
        "duckdb/third_party/re2/re2/dfa.cc",
        "duckdb/third_party/re2/re2/filtered_re2.cc",
        "duckdb/third_party/re2/re2/mimics_pcre.cc",
        "duckdb/third_party/re2/re2/nfa.cc",
        "duckdb/third_party/re2/re2/onepass.cc",
        "duckdb/third_party/re2/re2/parse.cc",
        "duckdb/third_party/re2/re2/perl_groups.cc",
        "duckdb/third_party/re2/re2/prefilter.cc",
        "duckdb/third_party/re2/re2/prefilter_tree.cc",
        "duckdb/third_party/re2/re2/prog.cc",
        "duckdb/third_party/re2/re2/re2.cc",
        "duckdb/third_party/re2/re2/regexp.cc",
        "duckdb/third_party/re2/re2/set.cc",
        "duckdb/third_party/re2/re2/simplify.cc",
        "duckdb/third_party/re2/re2/stringpiece.cc",
        "duckdb/third_party/re2/re2/tostring.cc",
        "duckdb/third_party/re2/re2/unicode_casefold.cc",
        "duckdb/third_party/re2/re2/unicode_groups.cc",
        "duckdb/third_party/re2/util/rune.cc",
        "duckdb/third_party/re2/util/strutil.cc",
        "duckdb/third_party/skiplist/SkipList.cpp",
        "duckdb/third_party/snappy/snappy-sinksource.cc",
        "duckdb/third_party/snappy/snappy.cc",
        "duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp",
        "duckdb/third_party/thrift/thrift/transport/TBufferTransports.cpp",
        "duckdb/third_party/thrift/thrift/transport/TTransportException.cpp",
        "duckdb/third_party/utf8proc/utf8proc.cpp",
        "duckdb/third_party/utf8proc/utf8proc_wrapper.cpp",
        "duckdb/third_party/yyjson/yyjson.cpp",
        "duckdb/third_party/zstd/common/entropy_common.cpp",
        "duckdb/third_party/zstd/common/error_private.cpp",
        "duckdb/third_party/zstd/common/fse_decompress.cpp",
        "duckdb/third_party/zstd/common/xxhash.cpp",
        "duckdb/third_party/zstd/common/zstd_common.cpp",
        "duckdb/third_party/zstd/compress/fse_compress.cpp",
        "duckdb/third_party/zstd/compress/hist.cpp",
        "duckdb/third_party/zstd/compress/huf_compress.cpp",
        "duckdb/third_party/zstd/compress/zstd_compress.cpp",
        "duckdb/third_party/zstd/compress/zstd_compress_literals.cpp",
        "duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp",
        "duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp",
        "duckdb/third_party/zstd/compress/zstd_double_fast.cpp",
        "duckdb/third_party/zstd/compress/zstd_fast.cpp",
        "duckdb/third_party/zstd/compress/zstd_lazy.cpp",
        "duckdb/third_party/zstd/compress/zstd_ldm.cpp",
        "duckdb/third_party/zstd/compress/zstd_opt.cpp",
        "duckdb/third_party/zstd/decompress/huf_decompress.cpp",
        "duckdb/third_party/zstd/decompress/zstd_ddict.cpp",
        "duckdb/third_party/zstd/decompress/zstd_decompress.cpp",
        "duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp",
        "duckdb/ub_extension_icu_third_party_icu_common.cpp",
        "duckdb/ub_extension_icu_third_party_icu_i18n.cpp",
        "duckdb/ub_extension_json_json_functions.cpp",
        "duckdb/ub_src_catalog.cpp",
        "duckdb/ub_src_catalog_catalog_entry.cpp",
        "duckdb/ub_src_catalog_catalog_entry_dependency.cpp",
        "duckdb/ub_src_catalog_default.cpp",
        "duckdb/ub_src_common.cpp",
        "duckdb/ub_src_common_adbc.cpp",
        "duckdb/ub_src_common_adbc_nanoarrow.cpp",
        "duckdb/ub_src_common_arrow.cpp",
        "duckdb/ub_src_common_arrow_appender.cpp",
        "duckdb/ub_src_common_crypto.cpp",
        "duckdb/ub_src_common_enums.cpp",
        "duckdb/ub_src_common_exception.cpp",
        "duckdb/ub_src_common_operator.cpp",
        "duckdb/ub_src_common_progress_bar.cpp",
        "duckdb/ub_src_common_row_operations.cpp",
        "duckdb/ub_src_common_serializer.cpp",
        "duckdb/ub_src_common_sort.cpp",
        "duckdb/ub_src_common_tree_renderer.cpp",
        "duckdb/ub_src_common_types.cpp",
        "duckdb/ub_src_common_types_column.cpp",
        "duckdb/ub_src_common_types_row.cpp",
        "duckdb/ub_src_common_value_operations.cpp",
        "duckdb/ub_src_core_functions.cpp",
        "duckdb/ub_src_core_functions_aggregate_algebraic.cpp",
        "duckdb/ub_src_core_functions_aggregate_distributive.cpp",
        "duckdb/ub_src_core_functions_aggregate_holistic.cpp",
        "duckdb/ub_src_core_functions_aggregate_nested.cpp",
        "duckdb/ub_src_core_functions_aggregate_regression.cpp",
        "duckdb/ub_src_core_functions_scalar_array.cpp",
        "duckdb/ub_src_core_functions_scalar_bit.cpp",
        "duckdb/ub_src_core_functions_scalar_blob.cpp",
        "duckdb/ub_src_core_functions_scalar_date.cpp",
        "duckdb/ub_src_core_functions_scalar_debug.cpp",
        "duckdb/ub_src_core_functions_scalar_enum.cpp",
        "duckdb/ub_src_core_functions_scalar_generic.cpp",
        "duckdb/ub_src_core_functions_scalar_list.cpp",
        "duckdb/ub_src_core_functions_scalar_map.cpp",
        "duckdb/ub_src_core_functions_scalar_math.cpp",
        "duckdb/ub_src_core_functions_scalar_operators.cpp",
        "duckdb/ub_src_core_functions_scalar_random.cpp",
        "duckdb/ub_src_core_functions_scalar_string.cpp",
        "duckdb/ub_src_core_functions_scalar_struct.cpp",
        "duckdb/ub_src_core_functions_scalar_union.cpp",
        "duckdb/ub_src_execution.cpp",
        "duckdb/ub_src_execution_expression_executor.cpp",
        "duckdb/ub_src_execution_index.cpp",
        "duckdb/ub_src_execution_index_art.cpp",
        "duckdb/ub_src_execution_nested_loop_join.cpp",
        "duckdb/ub_src_execution_operator_aggregate.cpp",
        "duckdb/ub_src_execution_operator_csv_scanner_buffer_manager.cpp",
        "duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp",
        "duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp",
        "duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp",
        "duckdb/ub_src_execution_operator_csv_scanner_table_function.cpp",
        "duckdb/ub_src_execution_operator_csv_scanner_util.cpp",
        "duckdb/ub_src_execution_operator_filter.cpp",
        "duckdb/ub_src_execution_operator_helper.cpp",
        "duckdb/ub_src_execution_operator_join.cpp",
        "duckdb/ub_src_execution_operator_order.cpp",
        "duckdb/ub_src_execution_operator_persistent.cpp",
        "duckdb/ub_src_execution_operator_projection.cpp",
        "duckdb/ub_src_execution_operator_scan.cpp",
        "duckdb/ub_src_execution_operator_schema.cpp",
        "duckdb/ub_src_execution_operator_set.cpp",
        "duckdb/ub_src_execution_physical_plan.cpp",
        "duckdb/ub_src_function.cpp",
        "duckdb/ub_src_function_aggregate.cpp",
        "duckdb/ub_src_function_aggregate_distributive.cpp",
        "duckdb/ub_src_function_cast.cpp",
        "duckdb/ub_src_function_cast_union.cpp",
        "duckdb/ub_src_function_pragma.cpp",
        "duckdb/ub_src_function_scalar.cpp",
        "duckdb/ub_src_function_scalar_compressed_materialization.cpp",
        "duckdb/ub_src_function_scalar_generic.cpp",
        "duckdb/ub_src_function_scalar_list.cpp",
        "duckdb/ub_src_function_scalar_operators.cpp",
        "duckdb/ub_src_function_scalar_sequence.cpp",
        "duckdb/ub_src_function_scalar_string.cpp",
        "duckdb/ub_src_function_scalar_string_regexp.cpp",
        "duckdb/ub_src_function_scalar_struct.cpp",
        "duckdb/ub_src_function_scalar_system.cpp",
        "duckdb/ub_src_function_table.cpp",
        "duckdb/ub_src_function_table_arrow.cpp",
        "duckdb/ub_src_function_table_system.cpp",
        "duckdb/ub_src_function_table_version.cpp",
        "duckdb/ub_src_main.cpp",
        "duckdb/ub_src_main_buffered_data.cpp",
        "duckdb/ub_src_main_capi.cpp",
        "duckdb/ub_src_main_capi_cast.cpp",
        "duckdb/ub_src_main_chunk_scan_state.cpp",
        "duckdb/ub_src_main_extension.cpp",
        "duckdb/ub_src_main_relation.cpp",
        "duckdb/ub_src_main_secret.cpp",
        "duckdb/ub_src_main_settings.cpp",
        "duckdb/ub_src_optimizer.cpp",
        "duckdb/ub_src_optimizer_compressed_materialization.cpp",
        "duckdb/ub_src_optimizer_join_order.cpp",
        "duckdb/ub_src_optimizer_matcher.cpp",
        "duckdb/ub_src_optimizer_pullup.cpp",
        "duckdb/ub_src_optimizer_pushdown.cpp",
        "duckdb/ub_src_optimizer_rule.cpp",
        "duckdb/ub_src_optimizer_statistics_expression.cpp",
        "duckdb/ub_src_optimizer_statistics_operator.cpp",
        "duckdb/ub_src_parallel.cpp",
        "duckdb/ub_src_parser.cpp",
        "duckdb/ub_src_parser_constraints.cpp",
        "duckdb/ub_src_parser_expression.cpp",
        "duckdb/ub_src_parser_parsed_data.cpp",
        "duckdb/ub_src_parser_query_node.cpp",
        "duckdb/ub_src_parser_statement.cpp",
        "duckdb/ub_src_parser_tableref.cpp",
        "duckdb/ub_src_parser_transform_constraint.cpp",
        "duckdb/ub_src_parser_transform_expression.cpp",
        "duckdb/ub_src_parser_transform_helpers.cpp",
        "duckdb/ub_src_parser_transform_statement.cpp",
        "duckdb/ub_src_parser_transform_tableref.cpp",
        "duckdb/ub_src_planner.cpp",
        "duckdb/ub_src_planner_binder_expression.cpp",
        "duckdb/ub_src_planner_binder_query_node.cpp",
        "duckdb/ub_src_planner_binder_statement.cpp",
        "duckdb/ub_src_planner_binder_tableref.cpp",
        "duckdb/ub_src_planner_expression.cpp",
        "duckdb/ub_src_planner_expression_binder.cpp",
        "duckdb/ub_src_planner_filter.cpp",
        "duckdb/ub_src_planner_operator.cpp",
        "duckdb/ub_src_planner_subquery.cpp",
        "duckdb/ub_src_storage.cpp",
        "duckdb/ub_src_storage_buffer.cpp",
        "duckdb/ub_src_storage_checkpoint.cpp",
        "duckdb/ub_src_storage_compression.cpp",
        "duckdb/ub_src_storage_compression_alp.cpp",
        "duckdb/ub_src_storage_compression_chimp.cpp",
        "duckdb/ub_src_storage_metadata.cpp",
        "duckdb/ub_src_storage_serialization.cpp",
        "duckdb/ub_src_storage_statistics.cpp",
        "duckdb/ub_src_storage_table.cpp",
        "duckdb/ub_src_transaction.cpp"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "5.7"
}
Done.