munim-ffmpeg 0.1.0

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

@@ -0,0 +1,298 @@
+///
+/// NitroMunimFfmpeg-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `FFmpegSessionResult` to properly resolve imports.
+namespace margelo::nitro::munimffmpeg { struct FFmpegSessionResult; }
+// Forward declaration of `HybridMunimFfmpegSpec` to properly resolve imports.
+namespace margelo::nitro::munimffmpeg { class HybridMunimFfmpegSpec; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridMunimFfmpegSpec_cxx` to properly resolve imports.
+namespace NitroMunimFfmpeg { class HybridMunimFfmpegSpec_cxx; }
+
+// Include C++ defined types
+#include "FFmpegSessionResult.hpp"
+#include "HybridMunimFfmpegSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::munimffmpeg::bridge::swift {
+
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<FFmpegSessionResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<FFmpegSessionResult>>`.
+   */
+  using std__shared_ptr_Promise_FFmpegSessionResult__ = std::shared_ptr<Promise<FFmpegSessionResult>>;
+  inline std::shared_ptr<Promise<FFmpegSessionResult>> create_std__shared_ptr_Promise_FFmpegSessionResult__() noexcept {
+    return Promise<FFmpegSessionResult>::create();
+  }
+  inline PromiseHolder<FFmpegSessionResult> wrap_std__shared_ptr_Promise_FFmpegSessionResult__(std::shared_ptr<Promise<FFmpegSessionResult>> promise) noexcept {
+    return PromiseHolder<FFmpegSessionResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const FFmpegSessionResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const FFmpegSessionResult&)>`.
+   */
+  using Func_void_FFmpegSessionResult = std::function<void(const FFmpegSessionResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const FFmpegSessionResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_FFmpegSessionResult_Wrapper final {
+  public:
+    explicit Func_void_FFmpegSessionResult_Wrapper(std::function<void(const FFmpegSessionResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const FFmpegSessionResult& /* result */)>>(std::move(func))) {}
+    inline void call(FFmpegSessionResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const FFmpegSessionResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_FFmpegSessionResult create_Func_void_FFmpegSessionResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_FFmpegSessionResult_Wrapper wrap_Func_void_FFmpegSessionResult(Func_void_FFmpegSessionResult value) noexcept {
+    return Func_void_FFmpegSessionResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* message */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* message */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * message * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* message */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* message */)>>(std::move(func))) {}
+    inline void call(std::string message) const noexcept {
+      _function->operator()(message);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* message */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const std::string& /* message */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const std::string& / * message * /)>>`.
+   */
+  using std__optional_std__function_void_const_std__string_____message______ = std::optional<std::function<void(const std::string& /* message */)>>;
+  inline std::optional<std::function<void(const std::string& /* message */)>> create_std__optional_std__function_void_const_std__string_____message______(const std::function<void(const std::string& /* message */)>& value) noexcept {
+    return std::optional<std::function<void(const std::string& /* message */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_std__string_____message______(const std::optional<std::function<void(const std::string& /* message */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const std::string& /* message */)> get_std__optional_std__function_void_const_std__string_____message______(const std::optional<std::function<void(const std::string& /* message */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>
+  /**
+   * Specialized version of `std::function<void(double, double, double, double, double, double, double)>`.
+   */
+  using Func_void_double_double_double_double_double_double_double = std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * timeMs * /, double / * sizeBytes * /, double / * bitrateKbits * /, double / * speed * /, double / * videoFrameNumber * /, double / * fps * /, double / * quality * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_double_double_double_double_double_double_Wrapper final {
+  public:
+    explicit Func_void_double_double_double_double_double_double_double_Wrapper(std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>&& func): _function(std::make_unique<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>(std::move(func))) {}
+    inline void call(double timeMs, double sizeBytes, double bitrateKbits, double speed, double videoFrameNumber, double fps, double quality) const noexcept {
+      _function->operator()(timeMs, sizeBytes, bitrateKbits, speed, videoFrameNumber, fps, quality);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double_double_double_double_double_double_double create_Func_void_double_double_double_double_double_double_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_double_double_double_double_double_double_Wrapper wrap_Func_void_double_double_double_double_double_double_double(Func_void_double_double_double_double_double_double_double value) noexcept {
+    return Func_void_double_double_double_double_double_double_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(double / * timeMs * /, double / * sizeBytes * /, double / * bitrateKbits * /, double / * speed * /, double / * videoFrameNumber * /, double / * fps * /, double / * quality * /)>>`.
+   */
+  using std__optional_std__function_void_double____timeMs_____double____sizeBytes_____double____bitrateKbits_____double____speed_____double____videoFrameNumber_____double____fps_____double____quality______ = std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>;
+  inline std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>> create_std__optional_std__function_void_double____timeMs_____double____sizeBytes_____double____bitrateKbits_____double____speed_____double____videoFrameNumber_____double____fps_____double____quality______(const std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>& value) noexcept {
+    return std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_double____timeMs_____double____sizeBytes_____double____bitrateKbits_____double____speed_____double____videoFrameNumber_____double____fps_____double____quality______(const std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)> get_std__optional_std__function_void_double____timeMs_____double____sizeBytes_____double____bitrateKbits_____double____speed_____double____videoFrameNumber_____double____fps_____double____quality______(const std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<void(double /* sessionId */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* sessionId */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * sessionId * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* sessionId */)>&& func): _function(std::make_unique<std::function<void(double /* sessionId */)>>(std::move(func))) {}
+    inline void call(double sessionId) const noexcept {
+      _function->operator()(sessionId);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* sessionId */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(double /* sessionId */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(double / * sessionId * /)>>`.
+   */
+  using std__optional_std__function_void_double____sessionId______ = std::optional<std::function<void(double /* sessionId */)>>;
+  inline std::optional<std::function<void(double /* sessionId */)>> create_std__optional_std__function_void_double____sessionId______(const std::function<void(double /* sessionId */)>& value) noexcept {
+    return std::optional<std::function<void(double /* sessionId */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_double____sessionId______(const std::optional<std::function<void(double /* sessionId */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(double /* sessionId */)> get_std__optional_std__function_void_double____sessionId______(const std::optional<std::function<void(double /* sessionId */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   */
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
+    return Promise<std::string>::create();
+  }
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
+    return PromiseHolder<std::string>(std::move(promise));
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridMunimFfmpegSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridMunimFfmpegSpec>`.
+   */
+  using std__shared_ptr_HybridMunimFfmpegSpec_ = std::shared_ptr<HybridMunimFfmpegSpec>;
+  std::shared_ptr<HybridMunimFfmpegSpec> create_std__shared_ptr_HybridMunimFfmpegSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridMunimFfmpegSpec_(std__shared_ptr_HybridMunimFfmpegSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridMunimFfmpegSpec>
+  using std__weak_ptr_HybridMunimFfmpegSpec_ = std::weak_ptr<HybridMunimFfmpegSpec>;
+  inline std__weak_ptr_HybridMunimFfmpegSpec_ weakify_std__shared_ptr_HybridMunimFfmpegSpec_(const std::shared_ptr<HybridMunimFfmpegSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<FFmpegSessionResult>>>
+  using Result_std__shared_ptr_Promise_FFmpegSessionResult___ = Result<std::shared_ptr<Promise<FFmpegSessionResult>>>;
+  inline Result_std__shared_ptr_Promise_FFmpegSessionResult___ create_Result_std__shared_ptr_Promise_FFmpegSessionResult___(const std::shared_ptr<Promise<FFmpegSessionResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<FFmpegSessionResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_FFmpegSessionResult___ create_Result_std__shared_ptr_Promise_FFmpegSessionResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<FFmpegSessionResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+
+} // namespace margelo::nitro::munimffmpeg::bridge::swift

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

@@ -0,0 +1,51 @@
+///
+/// NitroMunimFfmpeg-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `FFmpegSessionResult` to properly resolve imports.
+namespace margelo::nitro::munimffmpeg { struct FFmpegSessionResult; }
+// Forward declaration of `HybridMunimFfmpegSpec` to properly resolve imports.
+namespace margelo::nitro::munimffmpeg { class HybridMunimFfmpegSpec; }
+
+// Include C++ defined types
+#include "FFmpegSessionResult.hpp"
+#include "HybridMunimFfmpegSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+// C++ helpers for Swift
+#include "NitroMunimFfmpeg-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridMunimFfmpegSpec_cxx` to properly resolve imports.
+namespace NitroMunimFfmpeg { class HybridMunimFfmpegSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("NitroMunimFfmpeg-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "NitroMunimFfmpeg".
+#include "NitroMunimFfmpeg-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<NitroMunimFfmpeg/NitroMunimFfmpeg-Swift.h>)
+#include <NitroMunimFfmpeg/NitroMunimFfmpeg-Swift.h>
+#else
+#error NitroMunimFfmpeg's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "NitroMunimFfmpeg", and try building the app first.
+#endif

package/nitrogen/generated/ios/NitroMunimFfmpegAutolinking.mm

@@ -0,0 +1,33 @@
+///
+/// NitroMunimFfmpegAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "NitroMunimFfmpeg-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridMunimFfmpegSpecSwift.hpp"
+
+@interface NitroMunimFfmpegAutolinking : NSObject
+@end
+
+@implementation NitroMunimFfmpegAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::munimffmpeg;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MunimFfmpeg",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridMunimFfmpegSpec> hybridObject = NitroMunimFfmpeg::NitroMunimFfmpegAutolinking::createMunimFfmpeg();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/NitroMunimFfmpegAutolinking.swift

@@ -0,0 +1,26 @@
+///
+/// NitroMunimFfmpegAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class NitroMunimFfmpegAutolinking {
+  public typealias bridge = margelo.nitro.munimffmpeg.bridge.swift
+
+  public static func createMunimFfmpeg() -> bridge.std__shared_ptr_HybridMunimFfmpegSpec_ {
+    let hybridObject = HybridMunimFfmpeg()
+    return { () -> bridge.std__shared_ptr_HybridMunimFfmpegSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isMunimFfmpegRecyclable() -> Bool {
+    return HybridMunimFfmpeg.self is any RecyclableView.Type
+  }
+}

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

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

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

@@ -0,0 +1,119 @@
+///
+/// HybridMunimFfmpegSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridMunimFfmpegSpec.hpp"
+
+// Forward declaration of `HybridMunimFfmpegSpec_cxx` to properly resolve imports.
+namespace NitroMunimFfmpeg { class HybridMunimFfmpegSpec_cxx; }
+
+// Forward declaration of `FFmpegSessionResult` to properly resolve imports.
+namespace margelo::nitro::munimffmpeg { struct FFmpegSessionResult; }
+
+#include <string>
+#include "FFmpegSessionResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <optional>
+#include <vector>
+#include <functional>
+
+#include "NitroMunimFfmpeg-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::munimffmpeg {
+
+  /**
+   * The C++ part of HybridMunimFfmpegSpec_cxx.swift.
+   *
+   * HybridMunimFfmpegSpecSwift (C++) accesses HybridMunimFfmpegSpec_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, HybridMunimFfmpegSpec_cxx can directly inherit from the C++ class HybridMunimFfmpegSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridMunimFfmpegSpecSwift: public virtual HybridMunimFfmpegSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridMunimFfmpegSpecSwift(const NitroMunimFfmpeg::HybridMunimFfmpegSpec_cxx& swiftPart):
+      HybridObject(HybridMunimFfmpegSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroMunimFfmpeg::HybridMunimFfmpegSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridMunimFfmpegSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::string getFfmpegVersion() noexcept override {
+      auto __result = _swiftPart.getFfmpegVersion();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<FFmpegSessionResult>> execute(const std::vector<std::string>& arguments_, const std::optional<std::function<void(const std::string& /* message */)>>& onLog, const std::optional<std::function<void(double /* timeMs */, double /* sizeBytes */, double /* bitrateKbits */, double /* speed */, double /* videoFrameNumber */, double /* fps */, double /* quality */)>>& onStatistics, const std::optional<std::function<void(double /* sessionId */)>>& onSessionCreated) override {
+      auto __result = _swiftPart.execute(arguments_, onLog, onStatistics, onSessionCreated);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<FFmpegSessionResult>> probe(const std::vector<std::string>& arguments_, const std::optional<std::function<void(const std::string& /* message */)>>& onLog, const std::optional<std::function<void(double /* sessionId */)>>& onSessionCreated) override {
+      auto __result = _swiftPart.probe(arguments_, onLog, onSessionCreated);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> getMediaInformation(const std::string& path) override {
+      auto __result = _swiftPart.getMediaInformation(path);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void cancel(std::optional<double> sessionId) override {
+      auto __result = _swiftPart.cancel(sessionId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void cancelAll() override {
+      auto __result = _swiftPart.cancelAll();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    NitroMunimFfmpeg::HybridMunimFfmpegSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::munimffmpeg

package/nitrogen/generated/ios/swift/FFmpegSessionResult.swift

@@ -0,0 +1,77 @@
+///
+/// FFmpegSessionResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `FFmpegSessionResult`, backed by a C++ struct.
+ */
+public typealias FFmpegSessionResult = margelo.nitro.munimffmpeg.FFmpegSessionResult
+
+public extension FFmpegSessionResult {
+  private typealias bridge = margelo.nitro.munimffmpeg.bridge.swift
+
+  /**
+   * Create a new instance of `FFmpegSessionResult`.
+   */
+  init(sessionId: Double, returnCode: Double, success: Bool, cancelled: Bool, state: String, durationMs: Double, output: String, failStackTrace: String?) {
+    self.init(sessionId, returnCode, success, cancelled, std.string(state), durationMs, std.string(output), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = failStackTrace {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var sessionId: Double {
+    return self.__sessionId
+  }
+  
+  @inline(__always)
+  var returnCode: Double {
+    return self.__returnCode
+  }
+  
+  @inline(__always)
+  var success: Bool {
+    return self.__success
+  }
+  
+  @inline(__always)
+  var cancelled: Bool {
+    return self.__cancelled
+  }
+  
+  @inline(__always)
+  var state: String {
+    return String(self.__state)
+  }
+  
+  @inline(__always)
+  var durationMs: Double {
+    return self.__durationMs
+  }
+  
+  @inline(__always)
+  var output: String {
+    return String(self.__output)
+  }
+  
+  @inline(__always)
+  var failStackTrace: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__failStackTrace) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__failStackTrace)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_FFmpegSessionResult.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_FFmpegSessionResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: FFmpegSessionResult) -> 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_FFmpegSessionResult {
+  public typealias bridge = margelo.nitro.munimffmpeg.bridge.swift
+
+  private let closure: (_ value: FFmpegSessionResult) -> Void
+
+  public init(_ closure: @escaping (_ value: FFmpegSessionResult) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: FFmpegSessionResult) -> Void {
+    self.closure(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_FFmpegSessionResult`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_FFmpegSessionResult>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_FFmpegSessionResult {
+    return Unmanaged<Func_void_FFmpegSessionResult>.fromOpaque(pointer).takeRetainedValue()
+  }
+}