react-native-webrtc-nitro 1.1.0 → 1.2.3

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/HybridPermissionsSpec.kt

@@ -0,0 +1,62 @@
+///
+/// HybridPermissionsSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the Permissions HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of Permissions.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridPermissionsSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject Permissions]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun query(permissionDesc: PermissionDescriptor): Promise<PermissionState>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun request(permissionDesc: PermissionDescriptor): Promise<PermissionState>
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridPermissionsSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/PermissionDescriptor.kt

@@ -0,0 +1,38 @@
+///
+/// PermissionDescriptor.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "PermissionDescriptor".
+ */
+@DoNotStrip
+@Keep
+data class PermissionDescriptor(
+  @DoNotStrip
+  @Keep
+  val name: PermissionName
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(name: PermissionName): PermissionDescriptor {
+      return PermissionDescriptor(name)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/PermissionName.kt

@@ -0,0 +1,21 @@
+///
+/// PermissionName.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "PermissionName".
+ */
+@DoNotStrip
+@Keep
+enum class PermissionName(@DoNotStrip @Keep val value: Int) {
+  CAMERA(0),
+  MICROPHONE(1);
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/webrtc/PermissionState.kt

@@ -0,0 +1,22 @@
+///
+/// PermissionState.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.webrtc
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "PermissionState".
+ */
+@DoNotStrip
+@Keep
+enum class PermissionState(@DoNotStrip @Keep val value: Int) {
+  DENIED(0),
+  GRANTED(1),
+  PROMPT(2);
+}

package/nitrogen/generated/ios/Webrtc-Swift-Cxx-Bridge.cpp

@@ -10,6 +10,7 @@
 // Include C++ implementation defined types
 #include "HybridCameraSpecSwift.hpp"
 #include "HybridMicrophoneSpecSwift.hpp"
+#include "HybridPermissionsSpecSwift.hpp"
 #include "HybridWebrtcViewSpecSwift.hpp"
 #include "Webrtc-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
@@ -64,6 +65,30 @@ namespace margelo::nitro::webrtc::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::function<void(PermissionState /* result */)>
+  Func_void_PermissionState create_Func_void_PermissionState(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = Webrtc::Func_void_PermissionState::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](PermissionState result) mutable -> void {
+      swiftClosure.call(static_cast<int>(result));
+    };
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridPermissionsSpec>
+  std::shared_ptr<HybridPermissionsSpec> create_std__shared_ptr_HybridPermissionsSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    Webrtc::HybridPermissionsSpec_cxx swiftPart = Webrtc::HybridPermissionsSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::webrtc::HybridPermissionsSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridPermissionsSpec_(std__shared_ptr_HybridPermissionsSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::webrtc::HybridPermissionsSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::webrtc::HybridPermissionsSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridPermissionsSpec\" is not implemented in Swift!");
+    }
+    #endif
+    Webrtc::HybridPermissionsSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridWebrtcViewSpec>
   std::shared_ptr<HybridWebrtcViewSpec> create_std__shared_ptr_HybridWebrtcViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     Webrtc::HybridWebrtcViewSpec_cxx swiftPart = Webrtc::HybridWebrtcViewSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/Webrtc-Swift-Cxx-Bridge.hpp

@@ -12,21 +12,29 @@
 namespace margelo::nitro::webrtc { class HybridCameraSpec; }
 // Forward declaration of `HybridMicrophoneSpec` to properly resolve imports.
 namespace margelo::nitro::webrtc { class HybridMicrophoneSpec; }
+// Forward declaration of `HybridPermissionsSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridPermissionsSpec; }
 // Forward declaration of `HybridWebrtcViewSpec` to properly resolve imports.
 namespace margelo::nitro::webrtc { class HybridWebrtcViewSpec; }
+// Forward declaration of `PermissionState` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class PermissionState; }
 
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridCameraSpec_cxx` to properly resolve imports.
 namespace Webrtc { class HybridCameraSpec_cxx; }
 // Forward declaration of `HybridMicrophoneSpec_cxx` to properly resolve imports.
 namespace Webrtc { class HybridMicrophoneSpec_cxx; }
+// Forward declaration of `HybridPermissionsSpec_cxx` to properly resolve imports.
+namespace Webrtc { class HybridPermissionsSpec_cxx; }
 // Forward declaration of `HybridWebrtcViewSpec_cxx` to properly resolve imports.
 namespace Webrtc { class HybridWebrtcViewSpec_cxx; }
 
 // Include C++ defined types
 #include "HybridCameraSpec.hpp"
 #include "HybridMicrophoneSpec.hpp"
+#include "HybridPermissionsSpec.hpp"
 #include "HybridWebrtcViewSpec.hpp"
+#include "PermissionState.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -131,6 +139,61 @@ namespace margelo::nitro::webrtc::bridge::swift {
   using std__weak_ptr_HybridMicrophoneSpec_ = std::weak_ptr<HybridMicrophoneSpec>;
   inline std__weak_ptr_HybridMicrophoneSpec_ weakify_std__shared_ptr_HybridMicrophoneSpec_(const std::shared_ptr<HybridMicrophoneSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: std::shared_ptr<Promise<PermissionState>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<PermissionState>>`.
+   */
+  using std__shared_ptr_Promise_PermissionState__ = std::shared_ptr<Promise<PermissionState>>;
+  inline std::shared_ptr<Promise<PermissionState>> create_std__shared_ptr_Promise_PermissionState__() noexcept {
+    return Promise<PermissionState>::create();
+  }
+  inline PromiseHolder<PermissionState> wrap_std__shared_ptr_Promise_PermissionState__(std::shared_ptr<Promise<PermissionState>> promise) noexcept {
+    return PromiseHolder<PermissionState>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(PermissionState /* result */)>
+  /**
+   * Specialized version of `std::function<void(PermissionState)>`.
+   */
+  using Func_void_PermissionState = std::function<void(PermissionState /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(PermissionState / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_PermissionState_Wrapper final {
+  public:
+    explicit Func_void_PermissionState_Wrapper(std::function<void(PermissionState /* result */)>&& func): _function(std::make_unique<std::function<void(PermissionState /* result */)>>(std::move(func))) {}
+    inline void call(int result) const noexcept {
+      _function->operator()(static_cast<PermissionState>(result));
+    }
+  private:
+    std::unique_ptr<std::function<void(PermissionState /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PermissionState create_Func_void_PermissionState(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PermissionState_Wrapper wrap_Func_void_PermissionState(Func_void_PermissionState value) noexcept {
+    return Func_void_PermissionState_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridPermissionsSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridPermissionsSpec>`.
+   */
+  using std__shared_ptr_HybridPermissionsSpec_ = std::shared_ptr<HybridPermissionsSpec>;
+  std::shared_ptr<HybridPermissionsSpec> create_std__shared_ptr_HybridPermissionsSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridPermissionsSpec_(std__shared_ptr_HybridPermissionsSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridPermissionsSpec>
+  using std__weak_ptr_HybridPermissionsSpec_ = std::weak_ptr<HybridPermissionsSpec>;
+  inline std__weak_ptr_HybridPermissionsSpec_ weakify_std__shared_ptr_HybridPermissionsSpec_(const std::shared_ptr<HybridPermissionsSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<PermissionState>>>
+  using Result_std__shared_ptr_Promise_PermissionState___ = Result<std::shared_ptr<Promise<PermissionState>>>;
+  inline Result_std__shared_ptr_Promise_PermissionState___ create_Result_std__shared_ptr_Promise_PermissionState___(const std::shared_ptr<Promise<PermissionState>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<PermissionState>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_PermissionState___ create_Result_std__shared_ptr_Promise_PermissionState___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<PermissionState>>>::withError(error);
+  }
+  
   // pragma MARK: std::optional<std::string>
   /**
    * Specialized version of `std::optional<std::string>`.

package/nitrogen/generated/ios/Webrtc-Swift-Cxx-Umbrella.hpp

@@ -12,13 +12,25 @@
 namespace margelo::nitro::webrtc { class HybridCameraSpec; }
 // Forward declaration of `HybridMicrophoneSpec` to properly resolve imports.
 namespace margelo::nitro::webrtc { class HybridMicrophoneSpec; }
+// Forward declaration of `HybridPermissionsSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridPermissionsSpec; }
 // Forward declaration of `HybridWebrtcViewSpec` to properly resolve imports.
 namespace margelo::nitro::webrtc { class HybridWebrtcViewSpec; }
+// Forward declaration of `PermissionDescriptor` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct PermissionDescriptor; }
+// Forward declaration of `PermissionName` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class PermissionName; }
+// Forward declaration of `PermissionState` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class PermissionState; }
 
 // Include C++ defined types
 #include "HybridCameraSpec.hpp"
 #include "HybridMicrophoneSpec.hpp"
+#include "HybridPermissionsSpec.hpp"
 #include "HybridWebrtcViewSpec.hpp"
+#include "PermissionDescriptor.hpp"
+#include "PermissionName.hpp"
+#include "PermissionState.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -40,6 +52,8 @@ namespace margelo::nitro::webrtc { class HybridWebrtcViewSpec; }
 namespace Webrtc { class HybridCameraSpec_cxx; }
 // Forward declaration of `HybridMicrophoneSpec_cxx` to properly resolve imports.
 namespace Webrtc { class HybridMicrophoneSpec_cxx; }
+// Forward declaration of `HybridPermissionsSpec_cxx` to properly resolve imports.
+namespace Webrtc { class HybridPermissionsSpec_cxx; }
 // Forward declaration of `HybridWebrtcViewSpec_cxx` to properly resolve imports.
 namespace Webrtc { class HybridWebrtcViewSpec_cxx; }
 

package/nitrogen/generated/ios/WebrtcAutolinking.mm

@@ -10,6 +10,7 @@
 #import "Webrtc-Swift-Cxx-Umbrella.hpp"
 #import <type_traits>
 
+#include "HybridPermissionsSpecSwift.hpp"
 #include "HybridMicrophoneSpecSwift.hpp"
 #include "HybridCameraSpecSwift.hpp"
 #include "HybridMediaStreamTrack.hpp"
@@ -31,6 +32,13 @@
   using namespace margelo::nitro;
   using namespace margelo::nitro::webrtc;
 
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Permissions",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridPermissionsSpec> hybridObject = Webrtc::WebrtcAutolinking::createPermissions();
+      return hybridObject;
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Microphone",
     []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/ios/WebrtcAutolinking.swift

@@ -8,6 +8,21 @@
 public final class WebrtcAutolinking {
   public typealias bridge = margelo.nitro.webrtc.bridge.swift
 
+  /**
+   * Creates an instance of a Swift class that implements `HybridPermissionsSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridPermissionsSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridPermissions`).
+   */
+  public static func createPermissions() -> bridge.std__shared_ptr_HybridPermissionsSpec_ {
+    let hybridObject = HybridPermissions()
+    return { () -> bridge.std__shared_ptr_HybridPermissionsSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
   /**
    * Creates an instance of a Swift class that implements `HybridMicrophoneSpec`,
    * and wraps it in a Swift class that can directly interop with C++ (`HybridMicrophoneSpec_cxx`)

package/nitrogen/generated/ios/c++/HybridPermissionsSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridPermissionsSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridPermissionsSpecSwift.hpp"
+
+namespace margelo::nitro::webrtc {
+} // namespace margelo::nitro::webrtc

package/nitrogen/generated/ios/c++/HybridPermissionsSpecSwift.hpp

@@ -0,0 +1,92 @@
+///
+/// HybridPermissionsSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridPermissionsSpec.hpp"
+
+// Forward declaration of `HybridPermissionsSpec_cxx` to properly resolve imports.
+namespace Webrtc { class HybridPermissionsSpec_cxx; }
+
+// Forward declaration of `PermissionState` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class PermissionState; }
+// Forward declaration of `PermissionDescriptor` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct PermissionDescriptor; }
+// Forward declaration of `PermissionName` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class PermissionName; }
+
+#include "PermissionState.hpp"
+#include <NitroModules/Promise.hpp>
+#include "PermissionDescriptor.hpp"
+#include "PermissionName.hpp"
+
+#include "Webrtc-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  /**
+   * The C++ part of HybridPermissionsSpec_cxx.swift.
+   *
+   * HybridPermissionsSpecSwift (C++) accesses HybridPermissionsSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridPermissionsSpec_cxx can directly inherit from the C++ class HybridPermissionsSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridPermissionsSpecSwift: public virtual HybridPermissionsSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridPermissionsSpecSwift(const Webrtc::HybridPermissionsSpec_cxx& swiftPart):
+      HybridObject(HybridPermissionsSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline Webrtc::HybridPermissionsSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<PermissionState>> query(const PermissionDescriptor& permissionDesc) override {
+      auto __result = _swiftPart.query(std::forward<decltype(permissionDesc)>(permissionDesc));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<PermissionState>> request(const PermissionDescriptor& permissionDesc) override {
+      auto __result = _swiftPart.request(std::forward<decltype(permissionDesc)>(permissionDesc));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    Webrtc::HybridPermissionsSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::webrtc

package/nitrogen/generated/ios/swift/Func_void_PermissionState.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_PermissionState.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: PermissionState) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_PermissionState {
+  public typealias bridge = margelo.nitro.webrtc.bridge.swift
+
+  private let closure: (_ value: PermissionState) -> Void
+
+  public init(_ closure: @escaping (_ value: PermissionState) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: Int32) -> Void {
+    self.closure(margelo.nitro.webrtc.PermissionState(rawValue: value)!)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_PermissionState`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_PermissionState>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_PermissionState {
+    return Unmanaged<Func_void_PermissionState>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridPermissionsSpec.swift

@@ -0,0 +1,57 @@
+///
+/// HybridPermissionsSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridPermissionsSpec``
+public protocol HybridPermissionsSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func query(permissionDesc: PermissionDescriptor) throws -> Promise<PermissionState>
+  func request(permissionDesc: PermissionDescriptor) throws -> Promise<PermissionState>
+}
+
+public extension HybridPermissionsSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject Permissions]"
+  }
+}
+
+/// See ``HybridPermissionsSpec``
+open class HybridPermissionsSpec_base {
+  private weak var cxxWrapper: HybridPermissionsSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridPermissionsSpec_cxx {
+  #if DEBUG
+    guard self is HybridPermissionsSpec else {
+      fatalError("`self` is not a `HybridPermissionsSpec`! Did you accidentally inherit from `HybridPermissionsSpec_base` instead of `HybridPermissionsSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridPermissionsSpec_cxx(self as! HybridPermissionsSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the Permissions HybridObject.
+ * Implement this protocol to create Swift-based instances of Permissions.
+ * ```swift
+ * class HybridPermissions : HybridPermissionsSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridPermissionsSpec = HybridPermissionsSpec_protocol & HybridPermissionsSpec_base