@swiftbrowser/wasm-sdk-cxx 0.0.0-stage → 0.9.1

package/wasm32-unknown-wasip1/swift.xctoolchain/usr/lib/swift_static/wasi/Cxx.swiftmodule/wasm32-unknown-wasip1.swiftinterface

@@ -0,0 +1,855 @@
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Swift version 6.4 (swift-6.4-RELEASE)
+// swift-module-flags: -target wasm32-unknown-wasip1 -disable-objc-interop -enable-library-evolution -static -language-mode 5 -O -library-level api -enforce-exclusivity=unchecked -disable-objc-interop -target-min-inlining-version min -enable-experimental-feature SuppressedAssociatedTypesWithDefaults -enable-experimental-feature NonescapableTypes -enable-experimental-feature LifetimeDependence -enable-experimental-feature InoutLifetimeDependence -enable-experimental-feature LifetimeDependenceMutableAccessors -enable-experimental-feature Lifetimes -enable-upcoming-feature MemberImportVisibility -enable-experimental-feature BuiltinModule -enable-experimental-feature AllowUnsafeAttribute -enable-experimental-feature Lifetimes -enable-experimental-feature SuppressedAssociatedTypesWithDefaults -module-name Cxx
+// swift-module-flags-ignorable: -enable-lexical-lifetimes=false -strict-memory-safety -formal-cxx-interoperability-mode=swift-6 -interface-compiler-version 6.4
+import Builtin
+import Swift
+public protocol CxxConvertibleToBool {
+  func __convertToBool() -> Swift::Bool
+}
+extension Swift::Bool {
+  @inlinable public init<B>(fromCxx convertible: __shared B) where B : Cxx::CxxConvertibleToBool {
+    self = convertible.__convertToBool()
+  }
+}
+public protocol CxxConvertibleToCollection<Element> {
+  associatedtype Element where Self.Element == Self.RawIterator.Pointee
+  associatedtype RawIterator : Cxx::UnsafeCxxInputIterator
+  func __beginUnsafe() -> Self.RawIterator
+  func __endUnsafe() -> Self.RawIterator
+}
+extension Cxx::CxxConvertibleToCollection {
+  @inlinable public func forEach(_ body: (Self.RawIterator.Pointee) throws -> Swift::Void) rethrows {
+    var rawIterator = __beginUnsafe()
+    let endIterator = __endUnsafe()
+    while rawIterator != endIterator {
+      try body(rawIterator.pointee)
+      rawIterator = rawIterator.successor()
+    }
+  }
+}
+extension Cxx::CxxConvertibleToCollection where Self : Swift::Sequence {
+  @inlinable public func forEach(_ body: (Self.Element) throws -> Swift::Void) rethrows {
+    for element in self {
+      try body(element)
+    }
+  }
+}
+extension Swift::RangeReplaceableCollection {
+  @inlinable public init<C>(_ elements: __shared C) where C : Cxx::CxxConvertibleToCollection, Self.Element == C.Element {
+
+    self.init()
+    elements.forEach { self.append($0) }
+  }
+}
+extension Swift::SetAlgebra {
+  @inlinable public init<C>(_ elements: __shared C) where C : Cxx::CxxConvertibleToCollection, Self.Element == C.Element {
+
+    self.init()
+    elements.forEach { self.insert($0) }
+  }
+}
+public protocol CxxDictionary<Key, Value> : Swift::ExpressibleByDictionaryLiteral {
+  override associatedtype Key
+  override associatedtype Value
+  associatedtype Element : Cxx::CxxPair where Self.Element == Self.RawIterator.Pointee, Self.Key == Self.Element.First, Self.Value == Self.Element.Second
+  associatedtype RawIterator : Cxx::UnsafeCxxInputIterator where Self.RawIterator.Pointee == Self.RawMutableIterator.Pointee
+  associatedtype RawMutableIterator : Cxx::UnsafeCxxMutableInputIterator
+  associatedtype Size : Swift::BinaryInteger
+  associatedtype InsertionResult
+  init()
+  func __findUnsafe(_ key: Self.Key) -> Self.RawIterator
+  mutating func __findMutatingUnsafe(_ key: Self.Key) -> Self.RawMutableIterator
+  @discardableResult
+  mutating func __insertUnsafe(_ element: Self.Element) -> Self.InsertionResult
+  @discardableResult
+  mutating func erase(_ key: Self.Key) -> Self.Size
+  @discardableResult
+  mutating func __eraseUnsafe(_ iter: Self.RawMutableIterator) -> Self.RawMutableIterator
+  func __beginUnsafe() -> Self.RawIterator
+  func __endUnsafe() -> Self.RawIterator
+  mutating func __endMutatingUnsafe() -> Self.RawMutableIterator
+}
+extension Cxx::CxxDictionary {
+  @inlinable public init(_ dictionary: Swift::Dictionary<Self.Key, Self.Value>) where Self.Key : Swift::Hashable {
+    self.init()
+    for (key, value) in dictionary {
+      self[key] = value
+    }
+  }
+  @inlinable public init(dictionaryLiteral elements: (Self.Key, Self.Value)...) {
+    self.init()
+    for (key, value) in elements {
+      self[key] = value
+    }
+  }
+  @inlinable public init<S>(grouping values: __owned S, by keyForValue: (S.Element) throws -> Self.Key) rethrows where S : Swift::Sequence, Self.Value : Cxx::CxxVector, S.Element == Self.Value.Element {
+    self.init()
+    for value in values {
+      let key = try keyForValue(value)
+      var iter = __findMutatingUnsafe(key)
+      if iter != __endMutatingUnsafe() {
+        iter.pointee.second.push_back(value)
+      } else {
+        var vector = Value()
+        vector.push_back(value)
+        self[key] = vector
+      }
+    }
+  }
+  @inlinable public subscript(key: Self.Key) -> Self.Value? {
+    get {
+      let iter = __findUnsafe(key)
+      guard iter != __endUnsafe() else {
+        return nil
+      }
+      return iter.pointee.second
+    }
+    set(newValue) {
+      guard let newValue = newValue else {
+        self.erase(key)
+        return
+      }
+      var iter = self.__findMutatingUnsafe(key)
+      if iter != self.__endMutatingUnsafe() {
+         
+        iter.pointee.second = newValue
+      } else {
+         
+        let keyValuePair = Element(first: key, second: newValue)
+        self.__insertUnsafe(keyValuePair)
+      }
+    }
+  }
+  @inlinable public subscript(key: Self.Key, default defaultValue: @autoclosure () -> Self.Value) -> Self.Value {
+    get {
+      let iter = __findUnsafe(key)
+      guard iter != __endUnsafe() else {
+        return defaultValue()
+      }
+      return iter.pointee.second
+    }
+    set(newValue) {
+      var iter = self.__findMutatingUnsafe(key)
+      if iter != self.__endMutatingUnsafe() {
+        iter.pointee.second = newValue
+      } else {
+        let keyValuePair = Element(first: key, second: newValue)
+        self.__insertUnsafe(keyValuePair)
+      }
+    }
+  }
+  @inlinable public func mapValues<R, E>(_ transform: (Self.Value) throws(E) -> R.Value) throws(E) -> R where R : Cxx::CxxDictionary, E : Swift::Error, Self.Key == R.Key {
+    var result = R.init()
+
+    var iterator = __beginUnsafe()
+    let endIterator = __endUnsafe()
+
+    while iterator != endIterator {
+      let pair = iterator.pointee
+      try result.__insertUnsafe(R.Element(first: pair.first, second: transform(pair.second)))
+      iterator = iterator.successor()
+    }
+
+    return result
+  }
+  @inlinable @_disfavoredOverload public func mapValues<E>(_ transform: (Self.Value) throws(E) -> Self.Value) throws(E) -> Self where E : Swift::Error {
+    return try mapValues(transform) as Self
+  }
+  @inlinable public func compactMapValues<R, E>(_ transform: (Self.Value) throws(E) -> R.Value?) throws(E) -> R where R : Cxx::CxxDictionary, E : Swift::Error, Self.Key == R.Key {
+    var result = R.init()
+
+    var iterator = __beginUnsafe()
+    let endIterator = __endUnsafe()
+
+    while iterator != endIterator {
+      let pair = iterator.pointee
+      if let value = try transform(pair.second) {
+          result.__insertUnsafe(R.Element(first: pair.first, second: value))
+      }
+      iterator = iterator.successor()
+    }
+
+    return result
+  }
+  @inlinable @_disfavoredOverload public func compactMapValues<E>(_ transform: (Self.Value) throws(E) -> Self.Value?) throws(E) -> Self where E : Swift::Error {
+    return try compactMapValues(transform) as Self
+  }
+  public func filter(_ isIncluded: (_ key: Self.Key, _ value: Self.Value) throws -> Swift::Bool) rethrows -> Self
+  @discardableResult
+  @inlinable public mutating func removeValue(forKey key: Self.Key) -> Self.Value? {
+    let iter = self.__findMutatingUnsafe(key)
+    guard iter != self.__endMutatingUnsafe() else { return nil }
+
+    let value = iter.pointee.second
+    self.__eraseUnsafe(iter)
+    return value
+  }
+  @inlinable public mutating func merge<S, E>(_ other: __owned S, uniquingKeysWith combine: (Self.Value, Self.Value) throws(E) -> Self.Value) throws(E) where S : Swift::Sequence, E : Swift::Error, S.Element == (Self.Key, Self.Value) {
+    for (key, value) in other {
+      var iter = self.__findMutatingUnsafe(key)
+      if iter != self.__endMutatingUnsafe() {
+        iter.pointee.second = try combine(iter.pointee.second, value)
+      } else {
+        let keyValuePair = Element(first: key, second: value)
+        self.__insertUnsafe(keyValuePair)
+      }
+    }
+  }
+  @inlinable public mutating func merge<E>(_ other: __owned Swift::Dictionary<Self.Key, Self.Value>, uniquingKeysWith combine: (Self.Value, Self.Value) throws(E) -> Self.Value) throws(E) where E : Swift::Error, Self.Key : Swift::Hashable {
+    for (key, value) in other {
+      var iter = self.__findMutatingUnsafe(key)
+      if iter != self.__endMutatingUnsafe() {
+        iter.pointee.second = try combine(iter.pointee.second, value)
+      } else {
+        let keyValuePair = Element(first: key, second: value)
+        self.__insertUnsafe(keyValuePair)
+      }
+    }
+  }
+  @inlinable public mutating func merge<T, E>(_ other: __owned T, uniquingKeysWith combine: (Self.Value, Self.Value) throws(E) -> Self.Value) throws(E) where T : Cxx::CxxDictionary, E : Swift::Error, Self.Key == T.Key, Self.Value == T.Value {
+    var iterator = other.__beginUnsafe()
+    while iterator != other.__endUnsafe() {
+      var iter = self.__findMutatingUnsafe(iterator.pointee.first)
+      if iter != self.__endMutatingUnsafe() {
+        iter.pointee.second = try combine(iter.pointee.second, iterator.pointee.second)
+      } else {
+        let keyValuePair = Element(first: iterator.pointee.first, second: iterator.pointee.second)
+        self.__insertUnsafe(keyValuePair)
+      }
+      iterator = iterator.successor()
+    }
+  }
+  @inlinable public __consuming func merging<S, E>(_ other: __owned S, uniquingKeysWith combine: (Self.Value, Self.Value) throws(E) -> Self.Value) throws(E) -> Self where S : Swift::Sequence, E : Swift::Error, S.Element == (Self.Key, Self.Value) {
+    var result = self
+    try result.merge(other, uniquingKeysWith: combine)
+    return result
+  }
+  @inlinable public __consuming func merging<E>(_ other: __owned Swift::Dictionary<Self.Key, Self.Value>, uniquingKeysWith combine: (Self.Value, Self.Value) throws(E) -> Self.Value) throws(E) -> Self where E : Swift::Error, Self.Key : Swift::Hashable {
+    var result = self
+    try result.merge(other, uniquingKeysWith: combine)
+    return result
+  }
+  @inlinable public __consuming func merging<T, E>(_ other: __owned T, uniquingKeysWith combine: (Self.Value, Self.Value) throws(E) -> Self.Value) throws(E) -> Self where T : Cxx::CxxDictionary, E : Swift::Error, Self.Key == T.Key, Self.Value == T.Value {
+    var result = self
+    try result.merge(other, uniquingKeysWith: combine)
+    return result
+  }
+}
+extension Swift::Dictionary {
+  @inlinable public init(_ dictionary: some CxxDictionary<Key, Value>) {
+    self.init()
+
+    var it = dictionary.__beginUnsafe()
+    let endIterator = dictionary.__endUnsafe()
+    while it != endIterator {
+      self[it.pointee.first] = it.pointee.second
+      it = it.successor()
+    }
+    withExtendedLifetime(dictionary) {}
+  }
+}
+public protocol CxxPair<First, Second> : ~Copyable {
+  associatedtype First : ~Copyable
+  associatedtype Second : ~Copyable
+  init(first: consuming Self.First, second: consuming Self.Second)
+  var first: Self.First { get set }
+  var second: Self.Second { get set }
+}
+public protocol CxxOptional<Wrapped> : Swift::ExpressibleByNilLiteral {
+  associatedtype Wrapped
+  init()
+  init(_ value: Self.Wrapped)
+  func __convertToBool() -> Swift::Bool
+  var pointee: Self.Wrapped { get }
+}
+extension Cxx::CxxOptional {
+  public init(nilLiteral: ())
+  @inlinable public var hasValue: Swift::Bool {
+    get {
+      return __convertToBool()
+    }
+  }
+  @inlinable public var value: Self.Wrapped? {
+    get {
+      guard hasValue else { return nil }
+      return pointee
+    }
+    set(newValue) {
+      if let newValueNonNull = newValue {
+        self = Self.init(newValueNonNull)
+      } else {
+        self = Self.init()
+      }
+    }
+  }
+}
+extension Swift::Optional {
+  @inlinable public init(fromCxx value: some CxxOptional<Wrapped>) {
+    guard value.__convertToBool() else {
+      self = nil
+      return
+    }
+    self = value.pointee
+  }
+}
+public protocol CxxSet<Element> : Swift::ExpressibleByArrayLiteral {
+  associatedtype Element where Self.Element == Self.RawIterator.Pointee
+  associatedtype Size : Swift::BinaryInteger
+  associatedtype RawIterator : Cxx::UnsafeCxxInputIterator where Self.RawIterator.Pointee == Self.RawMutableIterator.Pointee
+  associatedtype RawMutableIterator : Cxx::UnsafeCxxInputIterator
+  associatedtype InsertionResult
+  init()
+  func __endUnsafe() -> Self.RawIterator
+  func __findUnsafe(_ value: Self.Element) -> Self.RawIterator
+  @discardableResult
+  mutating func __insertUnsafe(_ element: Self.Element) -> Self.InsertionResult
+  func count(_ element: Self.Element) -> Self.Size
+}
+extension Cxx::CxxSet {
+  @inlinable public init<S>(_ sequence: __shared S) where S : Swift::Sequence, Self.Element == S.Element {
+    self.init()
+    for item in sequence {
+      self.__insertUnsafe(item)
+    }
+  }
+  @inlinable public init(arrayLiteral elements: Self.Element...) {
+    self.init(elements)
+  }
+  @inlinable public func contains(_ element: Self.Element) -> Swift::Bool {
+    return self.__findUnsafe(element) != self.__endUnsafe()
+  }
+}
+public protocol CxxUniqueSet<Element> : Cxx::CxxSet where Self.InsertionResult : Cxx::CxxPair, Self.RawMutableIterator == Self.InsertionResult.First, Self.InsertionResult.Second == Swift::Bool {
+  override associatedtype InsertionResult
+  @discardableResult
+  mutating func __eraseUnsafe(_ iter: Self.RawIterator) -> Self.RawMutableIterator
+}
+extension Cxx::CxxUniqueSet {
+  @discardableResult
+  @inlinable public mutating func insert(_ newMember: Self.Element) -> (inserted: Swift::Bool, memberAfterInsert: Self.Element) {
+    let insertionResult = self.__insertUnsafe(newMember)
+    let rawIterator: RawMutableIterator = insertionResult.first
+    let inserted: Bool = insertionResult.second
+    return (inserted, rawIterator.pointee)
+  }
+  @discardableResult
+  @inlinable public mutating func remove(_ member: Self.Element) -> Self.Element? {
+    let iter = self.__findUnsafe(member)
+    guard iter != self.__endUnsafe() else {
+      return nil
+    }
+    let value = iter.pointee
+    self.__eraseUnsafe(iter)
+    return value
+  }
+}
+public protocol CxxRandomAccessCollection<Element> : Cxx::CxxSequence, Swift::RandomAccessCollection where Self.RawIterator : Cxx::UnsafeCxxRandomAccessIterator {
+  override associatedtype Element
+  override associatedtype RawIterator
+  override associatedtype Iterator = Cxx::CxxIterator<Self>
+  override associatedtype Index = Swift::Int
+  override associatedtype Indices = Swift::Range<Swift::Int>
+  override associatedtype SubSequence = Swift::Slice<Self>
+}
+extension Cxx::CxxRandomAccessCollection {
+  @inlinable public var startIndex: Swift::Int {
+    get {
+    return 0
+  }
+  }
+  @inlinable public var endIndex: Swift::Int {
+    get {
+    return count
+  }
+  }
+  @inlinable public var count: Swift::Int {
+    get {
+    return Int(__endUnsafe() - __beginUnsafe())
+  }
+  }
+  @inlinable @inline(__always) internal func _getRawIterator(at index: Swift::Int) -> Self.RawIterator {
+    var rawIterator = self.__beginUnsafe()
+    rawIterator += RawIterator.Distance(index)
+    precondition(self.__endUnsafe() - rawIterator > 0,
+        "C++ iterator access out of bounds")
+    return rawIterator
+  }
+  @inlinable public subscript(index: Swift::Int) -> Self.Element {
+    _read {
+      yield self._getRawIterator(at: index).pointee
+    }
+  }
+}
+public protocol CxxMutableRandomAccessCollection<Element> : Cxx::CxxRandomAccessCollection, Swift::MutableCollection {
+  associatedtype RawMutableIterator : Cxx::UnsafeCxxMutableRandomAccessIterator where Self.Element == Self.RawMutableIterator.Pointee
+  mutating func __beginMutatingUnsafe() -> Self.RawMutableIterator
+  mutating func __endMutatingUnsafe() -> Self.RawMutableIterator
+}
+extension Cxx::CxxMutableRandomAccessCollection {
+  @inlinable public subscript(index: Swift::Int) -> Self.Element {
+    _read {
+      yield self._getRawIterator(at: index).pointee
+    }
+    _modify {
+      var rawIterator = self.__beginMutatingUnsafe()
+      rawIterator += RawMutableIterator.Distance(index)
+      precondition(self.__endMutatingUnsafe() - rawIterator > 0,
+          "C++ iterator access out of bounds")
+      yield &rawIterator.pointee
+    }
+  }
+}
+public protocol CxxSequence<Element> : Cxx::CxxConvertibleToCollection, Swift::Sequence {
+  override associatedtype Element
+  override associatedtype RawIterator
+  override associatedtype Iterator = Cxx::CxxIterator<Self>
+  mutating func __beginUnsafe() -> Self.RawIterator
+  mutating func __endUnsafe() -> Self.RawIterator
+}
+@usableFromInline
+final internal class CxxSequenceBox<T> where T : Cxx::CxxSequence {
+  @usableFromInline
+  final internal var sequence: T
+  @usableFromInline
+  internal init(_ sequence: __shared T)
+  @usableFromInline
+  deinit
+}
+@frozen public struct CxxIterator<T> : Swift::IteratorProtocol where T : Cxx::CxxSequence {
+  public typealias Element = T.RawIterator.Pointee
+  @usableFromInline
+  internal let sequence: Cxx::CxxSequenceBox<T>
+  @usableFromInline
+  internal var rawIterator: T.RawIterator
+  @usableFromInline
+  internal let endIterator: T.RawIterator
+  @inlinable public init(sequence: __shared T) {
+    self.sequence = CxxSequenceBox<T>(sequence)
+    self.rawIterator = self.sequence.sequence.__beginUnsafe()
+    self.endIterator = self.sequence.sequence.__endUnsafe()
+  }
+  @inlinable public mutating func next() -> Cxx::CxxIterator<T>.Element? {
+    if self.rawIterator == self.endIterator {
+      return nil
+    }
+    let object = self.rawIterator.pointee
+    self.rawIterator = self.rawIterator.successor()
+    return object
+  }
+}
+extension Cxx::CxxSequence {
+  @inlinable public func makeIterator() -> Cxx::CxxIterator<Self> {
+    return CxxIterator(sequence: self)
+  }
+}
+#if canImport(Swift, _version: 6.5.0.7) || (canImport(Swift, _version: 6.4.0.30) && !canImport(Swift, _version: 6.5))
+@available(anyAppleOS 27.0, *)
+public protocol CxxIterable<Element> : Swift::Iterable, ~Copyable, ~Escapable where Self.Failure == Swift::Never {
+  override associatedtype Element : ~Copyable where Self.Element == Self.RawIterator.Pointee
+  override associatedtype BorrowingIterator : ~Copyable, ~Escapable = Cxx::CxxBorrowingIterator<Self>
+  associatedtype RawIterator : Cxx::UnsafeCxxInputIterator where Self.RawIterator.DereferenceResult : Swift::_Pointer, Self.RawIterator.Pointee == Self.RawIterator.DereferenceResult.Pointee
+  func __beginUnsafe() -> Self.RawIterator
+  func __endUnsafe() -> Self.RawIterator
+}
+#endif
+#if canImport(Swift, _version: 6.5.0.7) || (canImport(Swift, _version: 6.4.0.30) && !canImport(Swift, _version: 6.5))
+@available(anyAppleOS 27.0, *)
+@frozen public struct CxxBorrowingIterator<T> : Swift::BorrowingIteratorProtocol, ~Swift::Escapable, ~Swift::Copyable where T : Cxx::CxxIterable, T : ~Copyable, T : ~Escapable, T.Element : ~Copyable {
+  @usableFromInline
+  internal var current: T.RawIterator
+  @usableFromInline
+  internal let end: T.RawIterator
+  #if compiler(>=5.3) && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  @_lifetime(borrow sequence)
+  @inlinable public init(begin: T.RawIterator, end: T.RawIterator, sequence: borrowing T) {
+    self.current = begin
+    self.end = end
+  }
+  #else
+  @lifetime(borrow sequence)
+  @inlinable public init(begin: T.RawIterator, end: T.RawIterator, sequence: borrowing T) {
+    self.current = begin
+    self.end = end
+  }
+  #endif
+  #endif
+  @available(anyAppleOS 27.0, *)
+  public typealias Element = T.Element
+  @available(anyAppleOS 27.0, *)
+  public typealias Failure = Swift::Never
+}
+#endif
+#if canImport(Swift, _version: 6.5.0.7) || (canImport(Swift, _version: 6.4.0.30) && !canImport(Swift, _version: 6.5))
+@available(anyAppleOS 27.0, *)
+extension Cxx::CxxBorrowingIterator where T : ~Copyable, T : ~Escapable, T.Element : ~Copyable {
+  #if canImport(Swift, _version: 6.2)
+#if compiler(>=5.3) && $InoutLifetimeDependence && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  @_lifetime(&self)
+  @inlinable public mutating func nextSpan(maxCount: Swift::Int) -> Swift::Span<Cxx::CxxBorrowingIterator<T>.Element> {
+    if self.current == self.end {
+      return Span()
+    }
+
+    let rawPtr = self.current.__operatorStar()._rawValue
+    self.current = self.current.successor()
+    return _cxxOverrideLifetime(
+        Span(_unsafeStart: UnsafePointer(rawPtr), count: 1),
+        borrowing: self)
+  }
+  #else
+  @lifetime(&self)
+  @inlinable public mutating func nextSpan(maxCount: Swift::Int) -> Swift::Span<Cxx::CxxBorrowingIterator<T>.Element> {
+    if self.current == self.end {
+      return Span()
+    }
+
+    let rawPtr = self.current.__operatorStar()._rawValue
+    self.current = self.current.successor()
+    return _cxxOverrideLifetime(
+        Span(_unsafeStart: UnsafePointer(rawPtr), count: 1),
+        borrowing: self)
+  }
+  #endif
+  #endif
+  #endif
+}
+#endif
+#if canImport(Swift, _version: 6.5.0.7) || (canImport(Swift, _version: 6.4.0.30) && !canImport(Swift, _version: 6.5))
+@available(anyAppleOS 27.0, *)
+extension Cxx::CxxBorrowingIterator where T.RawIterator : Cxx::UnsafeCxxContiguousIterator, T : ~Copyable, T : ~Escapable, T.Element : ~Copyable {
+  #if canImport(Swift, _version: 6.2)
+#if compiler(>=5.3) && $InoutLifetimeDependence && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  @_lifetime(&self)
+  @inlinable public mutating func nextSpan() -> Swift::Span<Cxx::CxxBorrowingIterator<T>.Element> {
+    nextSpan(maxCount: Int.max)
+  }
+  #else
+  @lifetime(&self)
+  @inlinable public mutating func nextSpan() -> Swift::Span<Cxx::CxxBorrowingIterator<T>.Element> {
+    nextSpan(maxCount: Int.max)
+  }
+  #endif
+  #endif
+  #endif
+  public var count: Swift::Int {
+    get
+  }
+  #if canImport(Swift, _version: 6.2)
+#if compiler(>=5.3) && $InoutLifetimeDependence && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  @_lifetime(&self)
+  @inlinable public mutating func nextSpan(maxCount: Swift::Int) -> Swift::Span<Cxx::CxxBorrowingIterator<T>.Element> {
+    if maxCount < 1 || self.current == self.end {
+      return Span()
+    }
+
+    let rawPtr = self.current.__operatorStar()._rawValue
+    let distance = min(count, maxCount)
+    self.current += T.RawIterator.Distance(distance)
+    return _cxxOverrideLifetime(
+        Span(_unsafeStart: UnsafePointer(rawPtr), count: distance),
+        borrowing: self)
+  }
+  #else
+  @lifetime(&self)
+  @inlinable public mutating func nextSpan(maxCount: Swift::Int) -> Swift::Span<Cxx::CxxBorrowingIterator<T>.Element> {
+    if maxCount < 1 || self.current == self.end {
+      return Span()
+    }
+
+    let rawPtr = self.current.__operatorStar()._rawValue
+    let distance = min(count, maxCount)
+    self.current += T.RawIterator.Distance(distance)
+    return _cxxOverrideLifetime(
+        Span(_unsafeStart: UnsafePointer(rawPtr), count: distance),
+        borrowing: self)
+  }
+  #endif
+  #endif
+  #endif
+}
+#endif
+#if canImport(Swift, _version: 6.5.0.7) || (canImport(Swift, _version: 6.4.0.30) && !canImport(Swift, _version: 6.5))
+@available(anyAppleOS 27.0, *)
+extension Cxx::CxxIterable where Self : ~Copyable, Self.Element : ~Copyable {
+  #if compiler(>=5.3) && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  @_lifetime(borrow self)
+  @inlinable public borrowing func makeBorrowingIterator() -> Cxx::CxxBorrowingIterator<Self> {
+    let iterator = CxxBorrowingIterator<Self>(begin: __beginUnsafe(), end: __endUnsafe(), sequence: self)
+    return iterator
+  }
+  #else
+  @lifetime(borrow self)
+  @inlinable public borrowing func makeBorrowingIterator() -> Cxx::CxxBorrowingIterator<Self> {
+    let iterator = CxxBorrowingIterator<Self>(begin: __beginUnsafe(), end: __endUnsafe(), sequence: self)
+    return iterator
+  }
+  #endif
+  #endif
+}
+#endif
+public protocol CxxVector<Element> : Swift::ExpressibleByArrayLiteral {
+  associatedtype Element where Self.Element == Self.RawIterator.Pointee
+  associatedtype RawIterator : Cxx::UnsafeCxxRandomAccessIterator
+  associatedtype Size : Swift::BinaryInteger
+  init()
+  mutating func push_back(_ element: Self.Element)
+  func size() -> Self.Size
+  func __dataUnsafe() -> Swift::UnsafePointer<Self.Element>?
+}
+extension Cxx::CxxVector {
+  @inlinable public init<S>(_ sequence: __shared S) where S : Swift::Sequence, Self.Element == S.Element {
+    self.init()
+    for item in sequence {
+      self.push_back(item)
+    }
+  }
+}
+extension Cxx::CxxVector {
+  @inlinable public init(arrayLiteral elements: Self.Element...) {
+    self.init(elements)
+  }
+}
+@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
+extension Cxx::CxxVector {
+  #if canImport(Swift, _version: 6.2)
+#if compiler(>=5.3) && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  public var span: Swift::Span<Self.Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient borrowing get {
+      let buffer = UnsafeBufferPointer(start: self.__dataUnsafe(), count: Int(self.size()))
+      let span = Span(_unsafeElements: buffer)
+      return _cxxOverrideLifetime(span, borrowing: self)
+    }
+  }
+  #else
+  public var span: Swift::Span<Self.Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient borrowing get {
+      let buffer = UnsafeBufferPointer(start: self.__dataUnsafe(), count: Int(self.size()))
+      let span = Span(_unsafeElements: buffer)
+      return _cxxOverrideLifetime(span, borrowing: self)
+    }
+  }
+  #endif
+  #endif
+  #endif
+}
+@usableFromInline
+internal func unsafeBitCast<T, U>(_ x: consuming T, to type: U.Type) -> U where T : ~Copyable, T : ~Escapable
+#if compiler(>=5.3) && $LifetimeDependence
+#if compiler(>=5.3) && $Lifetimes
+@lifetime(borrow source)
+@unsafe @_unsafeNonescapableResult @_alwaysEmitIntoClient @_transparent public func _cxxOverrideLifetime<T, U>(_ dependent: consuming T, borrowing source: borrowing U) -> T where T : ~Copyable, T : ~Escapable, U : ~Copyable, U : ~Escapable {
+   
+   
+  dependent
+}
+#else
+@lifetime(borrow source)
+@unsafe @_unsafeNonescapableResult @_alwaysEmitIntoClient @_transparent public func _cxxOverrideLifetime<T, U>(_ dependent: consuming T, borrowing source: borrowing U) -> T where T : ~Copyable, T : ~Escapable, U : ~Copyable, U : ~Escapable {
+   
+   
+  dependent
+}
+#endif
+#endif
+#if compiler(>=5.3) && $LifetimeDependence
+#if compiler(>=5.3) && $Lifetimes
+@lifetime(copy source)
+@unsafe @_unsafeNonescapableResult @_alwaysEmitIntoClient @_transparent public func _cxxOverrideLifetime<T, U>(_ dependent: consuming T, copying source: borrowing U) -> T where T : ~Copyable, T : ~Escapable, U : ~Copyable, U : ~Escapable {
+   
+   
+  dependent
+}
+#else
+@lifetime(copy source)
+@unsafe @_unsafeNonescapableResult @_alwaysEmitIntoClient @_transparent public func _cxxOverrideLifetime<T, U>(_ dependent: consuming T, copying source: borrowing U) -> T where T : ~Copyable, T : ~Escapable, U : ~Copyable, U : ~Escapable {
+   
+   
+  dependent
+}
+#endif
+#endif
+public protocol CxxSpan<Element> {
+  associatedtype Element : ~Copyable
+  associatedtype Size : Swift::BinaryInteger
+  init()
+  init(_ unsafePointer: Swift::UnsafePointer<Self.Element>!, _ count: Self.Size)
+  func size() -> Self.Size
+  func __dataUnsafe() -> Swift::UnsafePointer<Self.Element>?
+}
+extension Cxx::CxxSpan where Self.Element : ~Copyable {
+  @_alwaysEmitIntoClient public init(_ unsafeBufferPointer: Swift::UnsafeBufferPointer<Self.Element>) {
+    precondition(unsafeBufferPointer.baseAddress != nil, 
+                  "UnsafeBufferPointer should not point to nil")
+    self.init(unsafeBufferPointer.baseAddress!, Size(unsafeBufferPointer.count))
+  }
+  @_alwaysEmitIntoClient public init(_ unsafeMutableBufferPointer: Swift::UnsafeMutableBufferPointer<Self.Element>) {
+    precondition(unsafeMutableBufferPointer.baseAddress != nil, 
+                  "UnsafeMutableBufferPointer should not point to nil")
+    self.init(unsafeMutableBufferPointer.baseAddress!, Size(unsafeMutableBufferPointer.count))
+  }
+  #if canImport(Swift, _version: 6.2)
+@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
+  @_alwaysEmitIntoClient @unsafe public init(_ span: Swift::Span<Self.Element>) {
+    let p = span.withUnsafeBufferPointer {
+        $0
+    }
+    defer {
+      _fixLifetime(span)
+    }
+    self.init(p)
+  }
+  #endif
+}
+#if canImport(Swift, _version: 6.2)
+@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
+extension Swift::Span where Element : ~Copyable {
+  #if canImport(Swift, _version: 6.2)
+#if compiler(>=5.3) && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  @lifetime(borrow span)
+  @_alwaysEmitIntoClient @unsafe @_unsafeNonescapableResult public init<T>(_unsafeCxxSpan span: borrowing T) where Element == T.Element, T : Cxx::CxxSpan {
+    let buffer = UnsafeBufferPointer(start: span.__dataUnsafe(), count: Int(span.size()))
+    let newSpan = Span(_unsafeElements: buffer)
+     
+    self = _cxxOverrideLifetime(newSpan, borrowing: span)
+  }
+  #else
+  @lifetime(borrow span)
+  @_alwaysEmitIntoClient @unsafe @_unsafeNonescapableResult public init<T>(_unsafeCxxSpan span: borrowing T) where Element == T.Element, T : Cxx::CxxSpan {
+    let buffer = UnsafeBufferPointer(start: span.__dataUnsafe(), count: Int(span.size()))
+    let newSpan = Span(_unsafeElements: buffer)
+     
+    self = _cxxOverrideLifetime(newSpan, borrowing: span)
+  }
+  #endif
+  #endif
+  #endif
+}
+#endif
+#if canImport(Swift, _version: 6.2)
+@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
+extension Swift::MutableSpan where Element : ~Copyable {
+  #if canImport(Swift, _version: 6.2)
+#if compiler(>=5.3) && $LifetimeDependence
+  #if compiler(>=5.3) && $Lifetimes
+  @lifetime(borrow span)
+  @_alwaysEmitIntoClient @unsafe @_unsafeNonescapableResult public init<T>(_unsafeCxxSpan span: borrowing T) where Element == T.Element, T : Cxx::CxxMutableSpan {
+    let buffer = UnsafeMutableBufferPointer(start: span.__dataUnsafe(), count: Int(span.size()))
+    let newSpan = MutableSpan(_unsafeElements: buffer)
+     
+    self = _cxxOverrideLifetime(newSpan, borrowing: span)
+  }
+  #else
+  @lifetime(borrow span)
+  @_alwaysEmitIntoClient @unsafe @_unsafeNonescapableResult public init<T>(_unsafeCxxSpan span: borrowing T) where Element == T.Element, T : Cxx::CxxMutableSpan {
+    let buffer = UnsafeMutableBufferPointer(start: span.__dataUnsafe(), count: Int(span.size()))
+    let newSpan = MutableSpan(_unsafeElements: buffer)
+     
+    self = _cxxOverrideLifetime(newSpan, borrowing: span)
+  }
+  #endif
+  #endif
+  #endif
+}
+#endif
+public protocol CxxMutableSpan<Element> {
+  associatedtype Element : ~Copyable
+  associatedtype Size : Swift::BinaryInteger
+  init()
+  init(_ unsafeMutablePointer: Swift::UnsafeMutablePointer<Self.Element>!, _ count: Self.Size)
+  func size() -> Self.Size
+  func __dataUnsafe() -> Swift::UnsafeMutablePointer<Self.Element>?
+}
+extension Cxx::CxxMutableSpan where Self.Element : ~Copyable {
+  @_alwaysEmitIntoClient public init(_ unsafeMutableBufferPointer: Swift::UnsafeMutableBufferPointer<Self.Element>) {
+    precondition(unsafeMutableBufferPointer.baseAddress != nil, 
+                  "UnsafeMutableBufferPointer should not point to nil")
+    self.init(unsafeMutableBufferPointer.baseAddress!, Size(unsafeMutableBufferPointer.count))
+  }
+  #if canImport(Swift, _version: 6.2)
+@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
+  @_alwaysEmitIntoClient @unsafe public init(_ span: consuming Swift::MutableSpan<Self.Element>) {
+    let p = span.withUnsafeMutableBufferPointer {
+        $0
+    }
+    defer {
+      _fixLifetime(span)
+    }
+    self.init(p)
+  }
+  #endif
+}
+public protocol UnsafeCxxInputIterator : Swift::Equatable {
+  associatedtype Pointee : ~Copyable
+  associatedtype DereferenceResult
+  @_borrowed var pointee: Self.Pointee { get }
+  func successor() -> Self
+  func __operatorStar() -> Self.DereferenceResult
+}
+extension Swift::UnsafePointer : @unsafe Cxx::UnsafeCxxInputIterator where Pointee : ~Copyable {
+  public typealias DereferenceResult = Swift::UnsafePointer<Pointee>
+  @inlinable public func __operatorStar() -> Swift::UnsafePointer<Pointee>.Cxx::DereferenceResult {
+    return self
+  }
+}
+extension Swift::UnsafeMutablePointer : @unsafe Cxx::UnsafeCxxInputIterator where Pointee : ~Copyable {
+  public typealias DereferenceResult = Swift::UnsafeMutablePointer<Pointee>
+  @inlinable public func __operatorStar() -> Swift::UnsafeMutablePointer<Pointee>.Cxx::DereferenceResult {
+    return self
+  }
+}
+extension Swift::Optional : @unsafe Cxx::UnsafeCxxInputIterator where Wrapped : Cxx::UnsafeCxxInputIterator {
+  public typealias Pointee = Wrapped.Pointee
+  public typealias DereferenceResult = Wrapped.DereferenceResult
+  @inlinable public var pointee: Swift::Optional<Wrapped>.Pointee {
+    _read {
+      guard let value = self else {
+        fatalError("Could not dereference nullptr")
+      }
+      yield value.pointee
+    }
+  }
+  @inlinable public func successor() -> Swift::Optional<Wrapped> {
+    if let value = self {
+      return value.successor()
+    }
+    fatalError("Could not increment nullptr")
+  }
+  @inlinable public func __operatorStar() -> Swift::Optional<Wrapped>.DereferenceResult {
+    guard let value = self else {
+      fatalError("Could not dereference nullptr")
+    }
+    return value.__operatorStar()
+  }
+}
+public protocol UnsafeCxxMutableInputIterator : Cxx::UnsafeCxxInputIterator {
+  @_borrowed override var pointee: Self.Pointee { get set }
+}
+extension Swift::UnsafeMutablePointer : Cxx::UnsafeCxxMutableInputIterator where Pointee : ~Copyable {
+}
+public protocol UnsafeCxxRandomAccessIterator : Cxx::UnsafeCxxInputIterator {
+  associatedtype Distance : Swift::BinaryInteger
+  static func - (lhs: Self, rhs: Self) -> Self.Distance
+  static func += (lhs: inout Self, rhs: Self.Distance)
+}
+extension Swift::UnsafePointer : @unsafe Cxx::UnsafeCxxRandomAccessIterator where Pointee : ~Copyable {
+}
+extension Swift::UnsafeMutablePointer : @unsafe Cxx::UnsafeCxxRandomAccessIterator where Pointee : ~Copyable {
+}
+public protocol UnsafeCxxMutableRandomAccessIterator : Cxx::UnsafeCxxMutableInputIterator, Cxx::UnsafeCxxRandomAccessIterator {
+}
+extension Swift::UnsafeMutablePointer : Cxx::UnsafeCxxMutableRandomAccessIterator where Pointee : ~Copyable {
+}
+public protocol UnsafeCxxContiguousIterator : Cxx::UnsafeCxxRandomAccessIterator {
+}
+public protocol UnsafeCxxMutableContiguousIterator : Cxx::UnsafeCxxContiguousIterator, Cxx::UnsafeCxxMutableRandomAccessIterator {
+}