react-nitro-networking 0.0.0-stage → 0.0.1-alpha.7

package/nitrogen/generated/apple/c++/include/module.modulemap

@@ -0,0 +1,12 @@
+///
+/// module.modulemap
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+// Headers used by Swift belong to the AppleCxx module.
+// This implementation target must not claim them through an umbrella directory.
+module ReactNitroNetworkingSwiftBridge {
+  requires cplusplus
+}

package/nitrogen/generated/apple/swift/Callback_void.swift

@@ -0,0 +1,60 @@
+///
+/// Callback_void.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+internal import CxxStdlib
+internal import ReactNitroNetworkingAppleCxx
+
+public typealias Callback_void = margelo.nitro.networking.swift_bridge.Callback_void
+
+extension Callback_void {
+  public typealias Arguments = ()
+  public typealias Return = Void
+  public typealias AsyncResult = margelo.nitro.networking.swift_bridge.Promise_void
+  private typealias bridge = margelo.nitro.networking.swift_bridge
+
+  public borrowing func __nitroCallSync(_ arguments: Arguments) throws -> Return {
+    let __result = bridge.callSync_Callback_void(self)
+    if __result.hasError() {
+      throw RuntimeError.from(cppError: __result.error())
+    }
+  }
+  public borrowing func __nitroCallAsync(_ arguments: Arguments) -> AsyncResult {
+    return __callAsync()
+  }
+  public borrowing func __nitroCallAndForget(_ arguments: Arguments) {
+    __callAndForget()
+  }
+  public init(_ closure: @escaping @Sendable () throws -> Return) {
+    self = bridge.create_Callback_void(.init { () -> bridge.Result_void in
+      do {
+        try closure()
+        return bridge.Result_void.withValue()
+      } catch {
+        return bridge.Result_void.withError(error.toCpp())
+      }
+    })
+  }
+}
+
+extension Callback<(), Void> where Self == Callback_void {
+  /// Creates a native callback from an escaping Swift closure.
+  public static func native(_ closure: @escaping @Sendable () throws -> Void) -> Self {
+    return Self(closure)
+  }
+}
+
+extension Callback<(), Void> {
+  func toCpp() -> Callback_void {
+    if let value = self as? Callback_void {
+      return value
+    }
+    return Callback_void { () -> Void in
+      try self.callSync(())
+    }
+  }
+}

package/nitrogen/generated/apple/swift/Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx.swift

@@ -0,0 +1,66 @@
+///
+/// Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+internal import CxxStdlib
+internal import ReactNitroNetworkingAppleCxx
+
+public typealias Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx = margelo.nitro.networking.swift_bridge.Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx
+
+extension Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx {
+  public typealias Arguments = (Variant_ArrayBuffer_String)
+  public typealias Return = Void
+  public typealias AsyncResult = margelo.nitro.networking.swift_bridge.Promise_void
+  private typealias bridge = margelo.nitro.networking.swift_bridge
+
+  public func __nitroCallSync(_ arguments: Arguments) throws -> Return {
+    return try withUnsafePointer(to: Variant_ArrayBuffer_String_cxx(arguments)) { (param0: UnsafePointer<Variant_ArrayBuffer_String_cxx>) -> Return in
+      let __result = bridge.callSync_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(self, param0)
+      if __result.hasError() {
+        throw RuntimeError.from(cppError: __result.error())
+      }
+    }
+  }
+  public func __nitroCallAsync(_ arguments: Arguments) -> AsyncResult {
+    return withUnsafePointer(to: Variant_ArrayBuffer_String_cxx(arguments)) { (param0: UnsafePointer<Variant_ArrayBuffer_String_cxx>) -> AsyncResult in
+      return bridge.callAsync_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(self, param0)
+    }
+  }
+  public func __nitroCallAndForget(_ arguments: Arguments) {
+    return withUnsafePointer(to: Variant_ArrayBuffer_String_cxx(arguments)) { (param0: UnsafePointer<Variant_ArrayBuffer_String_cxx>) -> Void in
+      bridge.callAndForget_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(self, param0)
+    }
+  }
+  public init(_ closure: @escaping @Sendable (Variant_ArrayBuffer_String) throws -> Return) {
+    self = bridge.create_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(.init { (param0: UnsafeRawPointer!) -> bridge.Result_void in
+      do {
+        try closure(param0.load(as: Variant_ArrayBuffer_String_cxx.self).value)
+        return bridge.Result_void.withValue()
+      } catch {
+        return bridge.Result_void.withError(error.toCpp())
+      }
+    })
+  }
+}
+
+extension Callback<(Variant_ArrayBuffer_String), Void> where Self == Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx {
+  /// Creates a native callback from an escaping Swift closure.
+  public static func native(_ closure: @escaping @Sendable (Variant_ArrayBuffer_String) throws -> Void) -> Self {
+    return Self(closure)
+  }
+}
+
+extension Callback<(Variant_ArrayBuffer_String), Void> {
+  func toCpp() -> Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx {
+    if let value = self as? Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx {
+      return value
+    }
+    return Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx { (param0: Variant_ArrayBuffer_String) -> Void in
+      try self.callSync((param0))
+    }
+  }
+}

package/nitrogen/generated/apple/swift/Callback_void_std__exception_ptr.swift

@@ -0,0 +1,60 @@
+///
+/// Callback_void_std__exception_ptr.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+internal import CxxStdlib
+internal import ReactNitroNetworkingAppleCxx
+
+public typealias Callback_void_std__exception_ptr = margelo.nitro.networking.swift_bridge.Callback_void_std__exception_ptr
+
+extension Callback_void_std__exception_ptr {
+  public typealias Arguments = (any Error)
+  public typealias Return = Void
+  public typealias AsyncResult = margelo.nitro.networking.swift_bridge.Promise_void
+  private typealias bridge = margelo.nitro.networking.swift_bridge
+
+  public borrowing func __nitroCallSync(_ arguments: Arguments) throws -> Return {
+    let __result = bridge.callSync_Callback_void_std__exception_ptr(self, arguments.toCpp())
+    if __result.hasError() {
+      throw RuntimeError.from(cppError: __result.error())
+    }
+  }
+  public borrowing func __nitroCallAsync(_ arguments: Arguments) -> AsyncResult {
+    return __callAsync(arguments.toCpp())
+  }
+  public borrowing func __nitroCallAndForget(_ arguments: Arguments) {
+    __callAndForget(arguments.toCpp())
+  }
+  public init(_ closure: @escaping @Sendable (any Error) throws -> Return) {
+    self = bridge.create_Callback_void_std__exception_ptr(.init { (param0: std.exception_ptr) -> bridge.Result_void in
+      do {
+        try closure(RuntimeError.from(cppError: param0))
+        return bridge.Result_void.withValue()
+      } catch {
+        return bridge.Result_void.withError(error.toCpp())
+      }
+    })
+  }
+}
+
+extension Callback<(any Error), Void> where Self == Callback_void_std__exception_ptr {
+  /// Creates a native callback from an escaping Swift closure.
+  public static func native(_ closure: @escaping @Sendable (any Error) throws -> Void) -> Self {
+    return Self(closure)
+  }
+}
+
+extension Callback<(any Error), Void> {
+  func toCpp() -> Callback_void_std__exception_ptr {
+    if let value = self as? Callback_void_std__exception_ptr {
+      return value
+    }
+    return Callback_void_std__exception_ptr { (param0: any Error) -> Void in
+      try self.callSync((param0))
+    }
+  }
+}

package/nitrogen/generated/apple/swift/HybridNetworkingSpec.swift

@@ -0,0 +1,65 @@
+///
+/// HybridNetworkingSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+
+/// See ``HybridNetworkingSpec``
+public protocol HybridNetworkingSpec_protocol: HybridNetworkingSpec_base, HybridObject {
+  // Constructor
+
+
+  // Properties
+
+
+  // Methods
+
+
+  // Static Properties
+
+
+  // Static Methods
+  static func fetch(url: String) throws -> any Promise<(any HybridResponseSpec)>
+}
+
+public extension HybridNetworkingSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject Networking]"
+  }
+}
+
+/// See ``HybridNetworkingSpec``
+open class HybridNetworkingSpec_base {
+  private weak var cxxWrapper: HybridNetworkingSpec_cxx? = nil
+  public init() throws {
+  }
+  public final func getCxxWrapper() -> HybridNetworkingSpec_cxx {
+  #if DEBUG
+    guard self is any HybridNetworkingSpec else {
+      fatalError("`self` is not a `HybridNetworkingSpec`! Did you accidentally inherit from `HybridNetworkingSpec_base` instead of `HybridNetworkingSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridNetworkingSpec_cxx(self as! any HybridNetworkingSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the Networking HybridObject.
+ * Implement this protocol to create Swift-based instances of Networking.
+ * ```swift
+ * class HybridNetworking : HybridNetworkingSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridNetworkingSpec = HybridNetworkingSpec_protocol & HybridNetworkingSpec_base

package/nitrogen/generated/apple/swift/HybridNetworkingSpec_cxx.swift

@@ -0,0 +1,143 @@
+///
+/// HybridNetworkingSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+internal import NitroModules
+internal import CxxStdlib
+internal import ReactNitroNetworkingAppleCxx
+
+/**
+ * A class implementation that bridges HybridNetworkingSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ */
+@_expose(Cxx)
+public final class HybridNetworkingSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::networking::swift_bridge`)
+   * from `ReactNitroNetworkingAppleCxx/ReactNitroNetworkingAppleCxx.h`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.networking.swift_bridge
+
+  /**
+   * Holds the Swift implementation of `HybridNetworkingSpec`.
+   */
+  private let __implementation: HybridNetworking
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__networking__HybridNetworkingSpec_ = .init()
+
+  /**
+   * Create a new `HybridNetworkingSpec_cxx` that wraps the given `HybridNetworkingSpec`.
+   */
+  public init(_ implementation: any HybridNetworkingSpec) {
+    guard let implementation = implementation as? HybridNetworking else {
+      preconditionFailure("Networking selects HybridNetworking as its Swift implementation. Every instance must inherit HybridNetworking.")
+    }
+    self.__implementation = implementation
+
+  }
+
+  /**
+   * Get the actual `HybridNetworkingSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridNetworkingSpec() -> any HybridNetworkingSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridNetworkingSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridNetworkingSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(pointer: UnsafeMutableRawPointer) -> HybridNetworkingSpec_cxx {
+    return Unmanaged<HybridNetworkingSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * This handle keeps the original native object alive.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_ {
+    let cached = __cxxPart.lock()
+    if cached.use_count() > 0 {
+      return cached
+    }
+    let value = bridge.create_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(self.toUnsafe())
+    __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(value)
+    return value
+  }
+
+
+
+  // A static borrowing accessor lets C++ pass a const reference without copying it.
+  // TODO: Remove this adapter and call the instance method directly once
+  // https://github.com/swiftlang/swift/pull/92862 is merged and supported by our Swift toolchain.
+  @_spi(NitroCxx)
+  public static func getCxxPart(_ value: borrowing HybridNetworkingSpec_cxx) -> bridge.std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_ {
+    return value.getCxxPart()
+  }
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(__implementation) + __implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridNetworkingSpec_cxx) -> Bool {
+    return __implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    __implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return __implementation.toString()
+  }
+
+  // Properties
+
+  // Methods
+
+  // Static methods
+
+  public class func fetch(url: String, __outResult: UnsafeMutableRawPointer) -> bridge.Result_void {
+    do {
+      let value = try HybridNetworking.fetch(url: url)
+      __outResult.initializeMemory(as: margelo.nitro.networking.swift_bridge.Promise___ReactNitroNetworking__HybridResponseSpec_cxx.self, repeating: value.toCpp(), count: 1)
+      return bridge.Result_void.withValue()
+    } catch {
+      return bridge.Result_void.withError(error.toCpp())
+    }
+  }
+}

package/nitrogen/generated/apple/swift/HybridResponseSpec.swift

@@ -0,0 +1,74 @@
+///
+/// HybridResponseSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+
+/// See ``HybridResponseSpec``
+public protocol HybridResponseSpec_protocol: HybridResponseSpec_base, HybridObject {
+  // Constructor
+
+
+  // Properties
+  var headers: Dictionary<String, String> { get }
+  var status: Double { get }
+  var ok: Bool { get }
+  var statusText: String { get }
+  var url: String { get }
+  var redirected: Bool { get }
+  var type: ResponseType { get }
+  var bodyUsed: Bool { get }
+
+  // Methods
+  func arrayBuffer() throws -> any Promise<ArrayBuffer>
+  func json() throws -> any Promise<AnyJSON>
+  func text() throws -> any Promise<String>
+
+  // Static Properties
+
+
+  // Static Methods
+
+}
+
+public extension HybridResponseSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject Response]"
+  }
+}
+
+/// See ``HybridResponseSpec``
+open class HybridResponseSpec_base {
+  private weak var cxxWrapper: HybridResponseSpec_cxx? = nil
+  public init() throws {
+  }
+  public final func getCxxWrapper() -> HybridResponseSpec_cxx {
+  #if DEBUG
+    guard self is any HybridResponseSpec else {
+      fatalError("`self` is not a `HybridResponseSpec`! Did you accidentally inherit from `HybridResponseSpec_base` instead of `HybridResponseSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridResponseSpec_cxx(self as! any HybridResponseSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the Response HybridObject.
+ * Implement this protocol to create Swift-based instances of Response.
+ * ```swift
+ * class HybridResponse : HybridResponseSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridResponseSpec = HybridResponseSpec_protocol & HybridResponseSpec_base

package/nitrogen/generated/apple/swift/HybridResponseSpec_cxx.swift

@@ -0,0 +1,201 @@
+///
+/// HybridResponseSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+internal import NitroModules
+internal import CxxStdlib
+internal import ReactNitroNetworkingAppleCxx
+
+/**
+ * A class implementation that bridges HybridResponseSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ */
+@_expose(Cxx)
+public final class HybridResponseSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::networking::swift_bridge`)
+   * from `ReactNitroNetworkingAppleCxx/ReactNitroNetworkingAppleCxx.h`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.networking.swift_bridge
+
+  /**
+   * Holds the Swift implementation of `HybridResponseSpec`.
+   */
+  private let __implementation: HybridResponse
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__networking__HybridResponseSpec_ = .init()
+
+  /**
+   * Create a new `HybridResponseSpec_cxx` that wraps the given `HybridResponseSpec`.
+   */
+  public init(_ implementation: any HybridResponseSpec) {
+    guard let implementation = implementation as? HybridResponse else {
+      preconditionFailure("Response selects HybridResponse as its Swift implementation. Every instance must inherit HybridResponse.")
+    }
+    self.__implementation = implementation
+
+  }
+
+  /**
+   * Get the actual `HybridResponseSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridResponseSpec() -> any HybridResponseSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridResponseSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridResponseSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(pointer: UnsafeMutableRawPointer) -> HybridResponseSpec_cxx {
+    return Unmanaged<HybridResponseSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * This handle keeps the original native object alive.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_ {
+    let cached = __cxxPart.lock()
+    if cached.use_count() > 0 {
+      return cached
+    }
+    let value = bridge.create_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(self.toUnsafe())
+    __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(value)
+    return value
+  }
+
+
+
+  // A static borrowing accessor lets C++ pass a const reference without copying it.
+  // TODO: Remove this adapter and call the instance method directly once
+  // https://github.com/swiftlang/swift/pull/92862 is merged and supported by our Swift toolchain.
+  @_spi(NitroCxx)
+  public static func getCxxPart(_ value: borrowing HybridResponseSpec_cxx) -> bridge.std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_ {
+    return value.getCxxPart()
+  }
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(__implementation) + __implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridResponseSpec_cxx) -> Bool {
+    return __implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    __implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return __implementation.toString()
+  }
+
+  // Properties
+
+  public final func getHeaders() -> Record_swift__String_swift__String {
+    let value = __implementation.headers
+    return Record_swift__String_swift__String(value)
+  }
+
+  public final func getStatus() -> Double {
+    let value = __implementation.status
+    return value
+  }
+
+  public final func getOk() -> Bool {
+    let value = __implementation.ok
+    return value
+  }
+
+  public final func getStatusText() -> String {
+    let value = __implementation.statusText
+    return value
+  }
+
+  public final func getUrl() -> String {
+    let value = __implementation.url
+    return value
+  }
+
+  public final func getRedirected() -> Bool {
+    let value = __implementation.redirected
+    return value
+  }
+
+  public final func getType() -> ResponseType {
+    let value = __implementation.type
+    return value
+  }
+
+  public final func getBodyUsed() -> Bool {
+    let value = __implementation.bodyUsed
+    return value
+  }
+
+  // Methods
+
+  public final func arrayBuffer(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void {
+    do {
+      let value = try __implementation.arrayBuffer()
+      __outResult.initializeMemory(as: margelo.nitro.networking.swift_bridge.Promise_ArrayBuffer.self, repeating: value.toCpp(), count: 1)
+      return bridge.Result_void.withValue()
+    } catch {
+      return bridge.Result_void.withError(error.toCpp())
+    }
+  }
+
+  public final func json(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void {
+    do {
+      let value = try __implementation.json()
+      __outResult.initializeMemory(as: margelo.nitro.networking.swift_bridge.Promise_NitroModules__AnyJSON.self, repeating: value.toCpp(), count: 1)
+      return bridge.Result_void.withValue()
+    } catch {
+      return bridge.Result_void.withError(error.toCpp())
+    }
+  }
+
+  public final func text(__outResult: UnsafeMutableRawPointer) -> bridge.Result_void {
+    do {
+      let value = try __implementation.text()
+      __outResult.initializeMemory(as: margelo.nitro.networking.swift_bridge.Promise_swift__String.self, repeating: value.toCpp(), count: 1)
+      return bridge.Result_void.withValue()
+    } catch {
+      return bridge.Result_void.withError(error.toCpp())
+    }
+  }
+}