@onekeyfe/react-native-cloud-kit-module 1.1.6

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

@@ -0,0 +1,340 @@
+///
+/// CloudKitModule-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `AccountInfoResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct AccountInfoResult; }
+// Forward declaration of `HybridCloudKitModuleSpec` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { class HybridCloudKitModuleSpec; }
+// Forward declaration of `QueryRecordsResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct QueryRecordsResult; }
+// Forward declaration of `RecordResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct RecordResult; }
+// Forward declaration of `SaveRecordResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct SaveRecordResult; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridCloudKitModuleSpec_cxx` to properly resolve imports.
+namespace CloudKitModule { class HybridCloudKitModuleSpec_cxx; }
+
+// Include C++ defined types
+#include "AccountInfoResult.hpp"
+#include "HybridCloudKitModuleSpec.hpp"
+#include "QueryRecordsResult.hpp"
+#include "RecordResult.hpp"
+#include "SaveRecordResult.hpp"
+#include <NitroModules/FastVectorCopy.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::cloudkitmodule::bridge::swift {
+
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(bool /* result */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
+    inline void call(bool result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_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::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;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<AccountInfoResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<AccountInfoResult>>`.
+   */
+  using std__shared_ptr_Promise_AccountInfoResult__ = std::shared_ptr<Promise<AccountInfoResult>>;
+  inline std::shared_ptr<Promise<AccountInfoResult>> create_std__shared_ptr_Promise_AccountInfoResult__() noexcept {
+    return Promise<AccountInfoResult>::create();
+  }
+  inline PromiseHolder<AccountInfoResult> wrap_std__shared_ptr_Promise_AccountInfoResult__(std::shared_ptr<Promise<AccountInfoResult>> promise) noexcept {
+    return PromiseHolder<AccountInfoResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const AccountInfoResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const AccountInfoResult&)>`.
+   */
+  using Func_void_AccountInfoResult = std::function<void(const AccountInfoResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const AccountInfoResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_AccountInfoResult_Wrapper final {
+  public:
+    explicit Func_void_AccountInfoResult_Wrapper(std::function<void(const AccountInfoResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const AccountInfoResult& /* result */)>>(std::move(func))) {}
+    inline void call(AccountInfoResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const AccountInfoResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AccountInfoResult create_Func_void_AccountInfoResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_AccountInfoResult_Wrapper wrap_Func_void_AccountInfoResult(Func_void_AccountInfoResult value) noexcept {
+    return Func_void_AccountInfoResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<SaveRecordResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<SaveRecordResult>>`.
+   */
+  using std__shared_ptr_Promise_SaveRecordResult__ = std::shared_ptr<Promise<SaveRecordResult>>;
+  inline std::shared_ptr<Promise<SaveRecordResult>> create_std__shared_ptr_Promise_SaveRecordResult__() noexcept {
+    return Promise<SaveRecordResult>::create();
+  }
+  inline PromiseHolder<SaveRecordResult> wrap_std__shared_ptr_Promise_SaveRecordResult__(std::shared_ptr<Promise<SaveRecordResult>> promise) noexcept {
+    return PromiseHolder<SaveRecordResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const SaveRecordResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const SaveRecordResult&)>`.
+   */
+  using Func_void_SaveRecordResult = std::function<void(const SaveRecordResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const SaveRecordResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_SaveRecordResult_Wrapper final {
+  public:
+    explicit Func_void_SaveRecordResult_Wrapper(std::function<void(const SaveRecordResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const SaveRecordResult& /* result */)>>(std::move(func))) {}
+    inline void call(SaveRecordResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const SaveRecordResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_SaveRecordResult create_Func_void_SaveRecordResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_SaveRecordResult_Wrapper wrap_Func_void_SaveRecordResult(Func_void_SaveRecordResult value) noexcept {
+    return Func_void_SaveRecordResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<RecordResult>
+  /**
+   * Specialized version of `std::optional<RecordResult>`.
+   */
+  using std__optional_RecordResult_ = std::optional<RecordResult>;
+  inline std::optional<RecordResult> create_std__optional_RecordResult_(const RecordResult& value) noexcept {
+    return std::optional<RecordResult>(value);
+  }
+  inline bool has_value_std__optional_RecordResult_(const std::optional<RecordResult>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline RecordResult get_std__optional_RecordResult_(const std::optional<RecordResult>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<RecordResult>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<RecordResult>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_RecordResult___ = std::shared_ptr<Promise<std::optional<RecordResult>>>;
+  inline std::shared_ptr<Promise<std::optional<RecordResult>>> create_std__shared_ptr_Promise_std__optional_RecordResult___() noexcept {
+    return Promise<std::optional<RecordResult>>::create();
+  }
+  inline PromiseHolder<std::optional<RecordResult>> wrap_std__shared_ptr_Promise_std__optional_RecordResult___(std::shared_ptr<Promise<std::optional<RecordResult>>> promise) noexcept {
+    return PromiseHolder<std::optional<RecordResult>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<RecordResult>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<RecordResult>&)>`.
+   */
+  using Func_void_std__optional_RecordResult_ = std::function<void(const std::optional<RecordResult>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<RecordResult>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_RecordResult__Wrapper final {
+  public:
+    explicit Func_void_std__optional_RecordResult__Wrapper(std::function<void(const std::optional<RecordResult>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<RecordResult>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<RecordResult> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<RecordResult>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_RecordResult_ create_Func_void_std__optional_RecordResult_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_RecordResult__Wrapper wrap_Func_void_std__optional_RecordResult_(Func_void_std__optional_RecordResult_ value) noexcept {
+    return Func_void_std__optional_RecordResult__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<RecordResult>
+  /**
+   * Specialized version of `std::vector<RecordResult>`.
+   */
+  using std__vector_RecordResult_ = std::vector<RecordResult>;
+  inline std::vector<RecordResult> copy_std__vector_RecordResult_(const RecordResult* CONTIGUOUS_MEMORY NON_NULL data, size_t size) noexcept {
+    return margelo::nitro::FastVectorCopy<RecordResult>(data, size);
+  }
+  inline const RecordResult* CONTIGUOUS_MEMORY NON_NULL get_data_std__vector_RecordResult_(const std::vector<RecordResult>& vector) noexcept {
+    return vector.data();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<QueryRecordsResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<QueryRecordsResult>>`.
+   */
+  using std__shared_ptr_Promise_QueryRecordsResult__ = std::shared_ptr<Promise<QueryRecordsResult>>;
+  inline std::shared_ptr<Promise<QueryRecordsResult>> create_std__shared_ptr_Promise_QueryRecordsResult__() noexcept {
+    return Promise<QueryRecordsResult>::create();
+  }
+  inline PromiseHolder<QueryRecordsResult> wrap_std__shared_ptr_Promise_QueryRecordsResult__(std::shared_ptr<Promise<QueryRecordsResult>> promise) noexcept {
+    return PromiseHolder<QueryRecordsResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const QueryRecordsResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const QueryRecordsResult&)>`.
+   */
+  using Func_void_QueryRecordsResult = std::function<void(const QueryRecordsResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const QueryRecordsResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_QueryRecordsResult_Wrapper final {
+  public:
+    explicit Func_void_QueryRecordsResult_Wrapper(std::function<void(const QueryRecordsResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const QueryRecordsResult& /* result */)>>(std::move(func))) {}
+    inline void call(QueryRecordsResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const QueryRecordsResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_QueryRecordsResult create_Func_void_QueryRecordsResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_QueryRecordsResult_Wrapper wrap_Func_void_QueryRecordsResult(Func_void_QueryRecordsResult value) noexcept {
+    return Func_void_QueryRecordsResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridCloudKitModuleSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridCloudKitModuleSpec>`.
+   */
+  using std__shared_ptr_HybridCloudKitModuleSpec_ = std::shared_ptr<HybridCloudKitModuleSpec>;
+  std::shared_ptr<HybridCloudKitModuleSpec> create_std__shared_ptr_HybridCloudKitModuleSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridCloudKitModuleSpec_(std__shared_ptr_HybridCloudKitModuleSpec_ cppType) noexcept;
+  
+  // pragma MARK: std::weak_ptr<HybridCloudKitModuleSpec>
+  using std__weak_ptr_HybridCloudKitModuleSpec_ = std::weak_ptr<HybridCloudKitModuleSpec>;
+  inline std__weak_ptr_HybridCloudKitModuleSpec_ weakify_std__shared_ptr_HybridCloudKitModuleSpec_(const std::shared_ptr<HybridCloudKitModuleSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<AccountInfoResult>>>
+  using Result_std__shared_ptr_Promise_AccountInfoResult___ = Result<std::shared_ptr<Promise<AccountInfoResult>>>;
+  inline Result_std__shared_ptr_Promise_AccountInfoResult___ create_Result_std__shared_ptr_Promise_AccountInfoResult___(const std::shared_ptr<Promise<AccountInfoResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<AccountInfoResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_AccountInfoResult___ create_Result_std__shared_ptr_Promise_AccountInfoResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<AccountInfoResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<SaveRecordResult>>>
+  using Result_std__shared_ptr_Promise_SaveRecordResult___ = Result<std::shared_ptr<Promise<SaveRecordResult>>>;
+  inline Result_std__shared_ptr_Promise_SaveRecordResult___ create_Result_std__shared_ptr_Promise_SaveRecordResult___(const std::shared_ptr<Promise<SaveRecordResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<SaveRecordResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_SaveRecordResult___ create_Result_std__shared_ptr_Promise_SaveRecordResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<SaveRecordResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<RecordResult>>>>
+  using Result_std__shared_ptr_Promise_std__optional_RecordResult____ = Result<std::shared_ptr<Promise<std::optional<RecordResult>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_RecordResult____ create_Result_std__shared_ptr_Promise_std__optional_RecordResult____(const std::shared_ptr<Promise<std::optional<RecordResult>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<RecordResult>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_RecordResult____ create_Result_std__shared_ptr_Promise_std__optional_RecordResult____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<RecordResult>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<QueryRecordsResult>>>
+  using Result_std__shared_ptr_Promise_QueryRecordsResult___ = Result<std::shared_ptr<Promise<QueryRecordsResult>>>;
+  inline Result_std__shared_ptr_Promise_QueryRecordsResult___ create_Result_std__shared_ptr_Promise_QueryRecordsResult___(const std::shared_ptr<Promise<QueryRecordsResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<QueryRecordsResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_QueryRecordsResult___ create_Result_std__shared_ptr_Promise_QueryRecordsResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<QueryRecordsResult>>>::withError(error);
+  }
+
+} // namespace margelo::nitro::cloudkitmodule::bridge::swift

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

@@ -0,0 +1,74 @@
+///
+/// CloudKitModule-Swift-Cxx-Umbrella.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `AccountInfoResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct AccountInfoResult; }
+// Forward declaration of `DeleteRecordParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct DeleteRecordParams; }
+// Forward declaration of `FetchRecordParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct FetchRecordParams; }
+// Forward declaration of `HybridCloudKitModuleSpec` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { class HybridCloudKitModuleSpec; }
+// Forward declaration of `QueryRecordsParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct QueryRecordsParams; }
+// Forward declaration of `QueryRecordsResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct QueryRecordsResult; }
+// Forward declaration of `RecordExistsParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct RecordExistsParams; }
+// Forward declaration of `RecordResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct RecordResult; }
+// Forward declaration of `SaveRecordParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct SaveRecordParams; }
+// Forward declaration of `SaveRecordResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct SaveRecordResult; }
+
+// Include C++ defined types
+#include "AccountInfoResult.hpp"
+#include "DeleteRecordParams.hpp"
+#include "FetchRecordParams.hpp"
+#include "HybridCloudKitModuleSpec.hpp"
+#include "QueryRecordsParams.hpp"
+#include "QueryRecordsResult.hpp"
+#include "RecordExistsParams.hpp"
+#include "RecordResult.hpp"
+#include "SaveRecordParams.hpp"
+#include "SaveRecordResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+// C++ helpers for Swift
+#include "CloudKitModule-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 `HybridCloudKitModuleSpec_cxx` to properly resolve imports.
+namespace CloudKitModule { class HybridCloudKitModuleSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("CloudKitModule-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 "CloudKitModule".
+#include "CloudKitModule-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<CloudKitModule/CloudKitModule-Swift.h>)
+#include <CloudKitModule/CloudKitModule-Swift.h>
+#else
+#error CloudKitModule's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "CloudKitModule", and try building the app first.
+#endif

package/nitrogen/generated/ios/CloudKitModuleAutolinking.mm

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

package/nitrogen/generated/ios/CloudKitModuleAutolinking.swift

@@ -0,0 +1,25 @@
+///
+/// CloudKitModuleAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+public final class CloudKitModuleAutolinking {
+  public typealias bridge = margelo.nitro.cloudkitmodule.bridge.swift
+
+  /**
+   * Creates an instance of a Swift class that implements `HybridCloudKitModuleSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridCloudKitModuleSpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `CloudKitModule`).
+   */
+  public static func createCloudKitModule() -> bridge.std__shared_ptr_HybridCloudKitModuleSpec_ {
+    let hybridObject = CloudKitModule()
+    return { () -> bridge.std__shared_ptr_HybridCloudKitModuleSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+}

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

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

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

@@ -0,0 +1,150 @@
+///
+/// HybridCloudKitModuleSpecSwift.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 "HybridCloudKitModuleSpec.hpp"
+
+// Forward declaration of `HybridCloudKitModuleSpec_cxx` to properly resolve imports.
+namespace CloudKitModule { class HybridCloudKitModuleSpec_cxx; }
+
+// Forward declaration of `AccountInfoResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct AccountInfoResult; }
+// Forward declaration of `SaveRecordResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct SaveRecordResult; }
+// Forward declaration of `SaveRecordParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct SaveRecordParams; }
+// Forward declaration of `RecordResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct RecordResult; }
+// Forward declaration of `FetchRecordParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct FetchRecordParams; }
+// Forward declaration of `DeleteRecordParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct DeleteRecordParams; }
+// Forward declaration of `RecordExistsParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct RecordExistsParams; }
+// Forward declaration of `QueryRecordsResult` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct QueryRecordsResult; }
+// Forward declaration of `QueryRecordsParams` to properly resolve imports.
+namespace margelo::nitro::cloudkitmodule { struct QueryRecordsParams; }
+
+#include <NitroModules/Promise.hpp>
+#include "AccountInfoResult.hpp"
+#include <string>
+#include <optional>
+#include "SaveRecordResult.hpp"
+#include "SaveRecordParams.hpp"
+#include "RecordResult.hpp"
+#include "FetchRecordParams.hpp"
+#include "DeleteRecordParams.hpp"
+#include "RecordExistsParams.hpp"
+#include "QueryRecordsResult.hpp"
+#include <vector>
+#include "QueryRecordsParams.hpp"
+
+#include "CloudKitModule-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::cloudkitmodule {
+
+  /**
+   * The C++ part of HybridCloudKitModuleSpec_cxx.swift.
+   *
+   * HybridCloudKitModuleSpecSwift (C++) accesses HybridCloudKitModuleSpec_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, HybridCloudKitModuleSpec_cxx can directly inherit from the C++ class HybridCloudKitModuleSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridCloudKitModuleSpecSwift: public virtual HybridCloudKitModuleSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridCloudKitModuleSpecSwift(const CloudKitModule::HybridCloudKitModuleSpec_cxx& swiftPart):
+      HybridObject(HybridCloudKitModuleSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline CloudKitModule::HybridCloudKitModuleSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<bool>> isAvailable() override {
+      auto __result = _swiftPart.isAvailable();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<AccountInfoResult>> getAccountInfo() override {
+      auto __result = _swiftPart.getAccountInfo();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<SaveRecordResult>> saveRecord(const SaveRecordParams& params) override {
+      auto __result = _swiftPart.saveRecord(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::optional<RecordResult>>> fetchRecord(const FetchRecordParams& params) override {
+      auto __result = _swiftPart.fetchRecord(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> deleteRecord(const DeleteRecordParams& params) override {
+      auto __result = _swiftPart.deleteRecord(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> recordExists(const RecordExistsParams& params) override {
+      auto __result = _swiftPart.recordExists(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<QueryRecordsResult>> queryRecords(const QueryRecordsParams& params) override {
+      auto __result = _swiftPart.queryRecords(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    CloudKitModule::HybridCloudKitModuleSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::cloudkitmodule