@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,793 @@
+///
+/// NitroMap-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `Camera` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Camera; }
+// Forward declaration of `ClusterAnimationStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class ClusterAnimationStyle; }
+// Forward declaration of `ClusterConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ClusterConfig; }
+// Forward declaration of `ClusterPressEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ClusterPressEvent; }
+// Forward declaration of `ClusterStrategy` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class ClusterStrategy; }
+// Forward declaration of `Coordinate` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Coordinate; }
+// Forward declaration of `EdgePadding` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct EdgePadding; }
+// Forward declaration of `HybridNitroMapConfigSpec` to properly resolve imports.
+namespace margelo::nitro::nitromap { class HybridNitroMapConfigSpec; }
+// Forward declaration of `HybridNitroMapSpec` to properly resolve imports.
+namespace margelo::nitro::nitromap { class HybridNitroMapSpec; }
+// Forward declaration of `ImageMarkerConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct ImageMarkerConfig; }
+// Forward declaration of `MapBoundaries` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapBoundaries; }
+// Forward declaration of `MapError` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapError; }
+// Forward declaration of `MapPressEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapPressEvent; }
+// Forward declaration of `MapProvider` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MapProvider; }
+// Forward declaration of `MapStyleElement` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapStyleElement; }
+// Forward declaration of `MapStyler` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MapStyler; }
+// Forward declaration of `MapType` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MapType; }
+// Forward declaration of `MarkerAnimation` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MarkerAnimation; }
+// Forward declaration of `MarkerColor` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerColor; }
+// Forward declaration of `MarkerConfig` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerConfig; }
+// Forward declaration of `MarkerData` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerData; }
+// Forward declaration of `MarkerDragEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerDragEvent; }
+// Forward declaration of `MarkerPressEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct MarkerPressEvent; }
+// Forward declaration of `MarkerStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { enum class MarkerStyle; }
+// Forward declaration of `Point` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Point; }
+// Forward declaration of `PriceMarkerStyle` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct PriceMarkerStyle; }
+// Forward declaration of `RegionChangeEvent` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct RegionChangeEvent; }
+// Forward declaration of `Region` to properly resolve imports.
+namespace margelo::nitro::nitromap { struct Region; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridNitroMapConfigSpec_cxx` to properly resolve imports.
+namespace NitroMap { class HybridNitroMapConfigSpec_cxx; }
+// Forward declaration of `HybridNitroMapSpec_cxx` to properly resolve imports.
+namespace NitroMap { class HybridNitroMapSpec_cxx; }
+
+// Include C++ defined types
+#include "Camera.hpp"
+#include "ClusterAnimationStyle.hpp"
+#include "ClusterConfig.hpp"
+#include "ClusterPressEvent.hpp"
+#include "ClusterStrategy.hpp"
+#include "Coordinate.hpp"
+#include "EdgePadding.hpp"
+#include "HybridNitroMapConfigSpec.hpp"
+#include "HybridNitroMapSpec.hpp"
+#include "ImageMarkerConfig.hpp"
+#include "MapBoundaries.hpp"
+#include "MapError.hpp"
+#include "MapPressEvent.hpp"
+#include "MapProvider.hpp"
+#include "MapStyleElement.hpp"
+#include "MapStyler.hpp"
+#include "MapType.hpp"
+#include "MarkerAnimation.hpp"
+#include "MarkerColor.hpp"
+#include "MarkerConfig.hpp"
+#include "MarkerData.hpp"
+#include "MarkerDragEvent.hpp"
+#include "MarkerPressEvent.hpp"
+#include "MarkerStyle.hpp"
+#include "Point.hpp"
+#include "PriceMarkerStyle.hpp"
+#include "Region.hpp"
+#include "RegionChangeEvent.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#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::nitromap::bridge::swift {
+
+  // pragma MARK: std::optional<MapProvider>
+  /**
+   * Specialized version of `std::optional<MapProvider>`.
+   */
+  using std__optional_MapProvider_ = std::optional<MapProvider>;
+  inline std::optional<MapProvider> create_std__optional_MapProvider_(const MapProvider& value) noexcept {
+    return std::optional<MapProvider>(value);
+  }
+  inline bool has_value_std__optional_MapProvider_(const std::optional<MapProvider>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MapProvider get_std__optional_MapProvider_(const std::optional<MapProvider>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<Region>
+  /**
+   * Specialized version of `std::optional<Region>`.
+   */
+  using std__optional_Region_ = std::optional<Region>;
+  inline std::optional<Region> create_std__optional_Region_(const Region& value) noexcept {
+    return std::optional<Region>(value);
+  }
+  inline bool has_value_std__optional_Region_(const std::optional<Region>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Region get_std__optional_Region_(const std::optional<Region>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<MapType>
+  /**
+   * Specialized version of `std::optional<MapType>`.
+   */
+  using std__optional_MapType_ = std::optional<MapType>;
+  inline std::optional<MapType> create_std__optional_MapType_(const MapType& value) noexcept {
+    return std::optional<MapType>(value);
+  }
+  inline bool has_value_std__optional_MapType_(const std::optional<MapType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MapType get_std__optional_MapType_(const std::optional<MapType>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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::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;
+  }
+  
+  // pragma MARK: std::vector<MapStyler>
+  /**
+   * Specialized version of `std::vector<MapStyler>`.
+   */
+  using std__vector_MapStyler_ = std::vector<MapStyler>;
+  inline std::vector<MapStyler> create_std__vector_MapStyler_(size_t size) noexcept {
+    std::vector<MapStyler> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<MapStyleElement>
+  /**
+   * Specialized version of `std::vector<MapStyleElement>`.
+   */
+  using std__vector_MapStyleElement_ = std::vector<MapStyleElement>;
+  inline std::vector<MapStyleElement> create_std__vector_MapStyleElement_(size_t size) noexcept {
+    std::vector<MapStyleElement> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<MapStyleElement>>
+  /**
+   * Specialized version of `std::optional<std::vector<MapStyleElement>>`.
+   */
+  using std__optional_std__vector_MapStyleElement__ = std::optional<std::vector<MapStyleElement>>;
+  inline std::optional<std::vector<MapStyleElement>> create_std__optional_std__vector_MapStyleElement__(const std::vector<MapStyleElement>& value) noexcept {
+    return std::optional<std::vector<MapStyleElement>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_MapStyleElement__(const std::optional<std::vector<MapStyleElement>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<MapStyleElement> get_std__optional_std__vector_MapStyleElement__(const std::optional<std::vector<MapStyleElement>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<std::string, MarkerColor>
+  /**
+   * Wrapper struct for `std::variant<std::string, MarkerColor>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_std__string__MarkerColor_ {
+    std::variant<std::string, MarkerColor> variant;
+    std__variant_std__string__MarkerColor_(std::variant<std::string, MarkerColor> variant): variant(variant) { }
+    operator std::variant<std::string, MarkerColor>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline std::string get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline MarkerColor get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_std__string__MarkerColor_ create_std__variant_std__string__MarkerColor_(const std::string& value) noexcept {
+    return std__variant_std__string__MarkerColor_(value);
+  }
+  inline std__variant_std__string__MarkerColor_ create_std__variant_std__string__MarkerColor_(const MarkerColor& value) noexcept {
+    return std__variant_std__string__MarkerColor_(value);
+  }
+  
+  // pragma MARK: std::optional<ClusterConfig>
+  /**
+   * Specialized version of `std::optional<ClusterConfig>`.
+   */
+  using std__optional_ClusterConfig_ = std::optional<ClusterConfig>;
+  inline std::optional<ClusterConfig> create_std__optional_ClusterConfig_(const ClusterConfig& value) noexcept {
+    return std::optional<ClusterConfig>(value);
+  }
+  inline bool has_value_std__optional_ClusterConfig_(const std::optional<ClusterConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ClusterConfig get_std__optional_ClusterConfig_(const std::optional<ClusterConfig>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const MapPressEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const MapPressEvent&)>`.
+   */
+  using Func_void_MapPressEvent = std::function<void(const MapPressEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const MapPressEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_MapPressEvent_Wrapper final {
+  public:
+    explicit Func_void_MapPressEvent_Wrapper(std::function<void(const MapPressEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const MapPressEvent& /* event */)>>(std::move(func))) {}
+    inline void call(MapPressEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const MapPressEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_MapPressEvent create_Func_void_MapPressEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_MapPressEvent_Wrapper wrap_Func_void_MapPressEvent(Func_void_MapPressEvent value) noexcept {
+    return Func_void_MapPressEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const MapPressEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const MapPressEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_MapPressEvent_____event______ = std::optional<std::function<void(const MapPressEvent& /* event */)>>;
+  inline std::optional<std::function<void(const MapPressEvent& /* event */)>> create_std__optional_std__function_void_const_MapPressEvent_____event______(const std::function<void(const MapPressEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const MapPressEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_MapPressEvent_____event______(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const MapPressEvent& /* event */)> get_std__optional_std__function_void_const_MapPressEvent_____event______(const std::optional<std::function<void(const MapPressEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void()>>
+  /**
+   * Specialized version of `std::optional<std::function<void()>>`.
+   */
+  using std__optional_std__function_void____ = std::optional<std::function<void()>>;
+  inline std::optional<std::function<void()>> create_std__optional_std__function_void____(const std::function<void()>& value) noexcept {
+    return std::optional<std::function<void()>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void____(const std::optional<std::function<void()>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void()> get_std__optional_std__function_void____(const std::optional<std::function<void()>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const RegionChangeEvent& /* region */)>
+  /**
+   * Specialized version of `std::function<void(const RegionChangeEvent&)>`.
+   */
+  using Func_void_RegionChangeEvent = std::function<void(const RegionChangeEvent& /* region */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RegionChangeEvent& / * region * /)>`, this can be used from Swift.
+   */
+  class Func_void_RegionChangeEvent_Wrapper final {
+  public:
+    explicit Func_void_RegionChangeEvent_Wrapper(std::function<void(const RegionChangeEvent& /* region */)>&& func): _function(std::make_unique<std::function<void(const RegionChangeEvent& /* region */)>>(std::move(func))) {}
+    inline void call(RegionChangeEvent region) const noexcept {
+      _function->operator()(region);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RegionChangeEvent& /* region */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RegionChangeEvent create_Func_void_RegionChangeEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RegionChangeEvent_Wrapper wrap_Func_void_RegionChangeEvent(Func_void_RegionChangeEvent value) noexcept {
+    return Func_void_RegionChangeEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RegionChangeEvent& /* region */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RegionChangeEvent& / * region * /)>>`.
+   */
+  using std__optional_std__function_void_const_RegionChangeEvent_____region______ = std::optional<std::function<void(const RegionChangeEvent& /* region */)>>;
+  inline std::optional<std::function<void(const RegionChangeEvent& /* region */)>> create_std__optional_std__function_void_const_RegionChangeEvent_____region______(const std::function<void(const RegionChangeEvent& /* region */)>& value) noexcept {
+    return std::optional<std::function<void(const RegionChangeEvent& /* region */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RegionChangeEvent_____region______(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RegionChangeEvent& /* region */)> get_std__optional_std__function_void_const_RegionChangeEvent_____region______(const std::optional<std::function<void(const RegionChangeEvent& /* region */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const MarkerPressEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const MarkerPressEvent&)>`.
+   */
+  using Func_void_MarkerPressEvent = std::function<void(const MarkerPressEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const MarkerPressEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_MarkerPressEvent_Wrapper final {
+  public:
+    explicit Func_void_MarkerPressEvent_Wrapper(std::function<void(const MarkerPressEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const MarkerPressEvent& /* event */)>>(std::move(func))) {}
+    inline void call(MarkerPressEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const MarkerPressEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_MarkerPressEvent create_Func_void_MarkerPressEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_MarkerPressEvent_Wrapper wrap_Func_void_MarkerPressEvent(Func_void_MarkerPressEvent value) noexcept {
+    return Func_void_MarkerPressEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const MarkerPressEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const MarkerPressEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_MarkerPressEvent_____event______ = std::optional<std::function<void(const MarkerPressEvent& /* event */)>>;
+  inline std::optional<std::function<void(const MarkerPressEvent& /* event */)>> create_std__optional_std__function_void_const_MarkerPressEvent_____event______(const std::function<void(const MarkerPressEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const MarkerPressEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_MarkerPressEvent_____event______(const std::optional<std::function<void(const MarkerPressEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const MarkerPressEvent& /* event */)> get_std__optional_std__function_void_const_MarkerPressEvent_____event______(const std::optional<std::function<void(const MarkerPressEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const MarkerDragEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const MarkerDragEvent&)>`.
+   */
+  using Func_void_MarkerDragEvent = std::function<void(const MarkerDragEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const MarkerDragEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_MarkerDragEvent_Wrapper final {
+  public:
+    explicit Func_void_MarkerDragEvent_Wrapper(std::function<void(const MarkerDragEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const MarkerDragEvent& /* event */)>>(std::move(func))) {}
+    inline void call(MarkerDragEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const MarkerDragEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_MarkerDragEvent create_Func_void_MarkerDragEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_MarkerDragEvent_Wrapper wrap_Func_void_MarkerDragEvent(Func_void_MarkerDragEvent value) noexcept {
+    return Func_void_MarkerDragEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const MarkerDragEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const MarkerDragEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_MarkerDragEvent_____event______ = std::optional<std::function<void(const MarkerDragEvent& /* event */)>>;
+  inline std::optional<std::function<void(const MarkerDragEvent& /* event */)>> create_std__optional_std__function_void_const_MarkerDragEvent_____event______(const std::function<void(const MarkerDragEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const MarkerDragEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_MarkerDragEvent_____event______(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const MarkerDragEvent& /* event */)> get_std__optional_std__function_void_const_MarkerDragEvent_____event______(const std::optional<std::function<void(const MarkerDragEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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 ClusterPressEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const ClusterPressEvent&)>`.
+   */
+  using Func_void_ClusterPressEvent = std::function<void(const ClusterPressEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const ClusterPressEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_ClusterPressEvent_Wrapper final {
+  public:
+    explicit Func_void_ClusterPressEvent_Wrapper(std::function<void(const ClusterPressEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const ClusterPressEvent& /* event */)>>(std::move(func))) {}
+    inline void call(ClusterPressEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const ClusterPressEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ClusterPressEvent create_Func_void_ClusterPressEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_ClusterPressEvent_Wrapper wrap_Func_void_ClusterPressEvent(Func_void_ClusterPressEvent value) noexcept {
+    return Func_void_ClusterPressEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const ClusterPressEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const ClusterPressEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_ClusterPressEvent_____event______ = std::optional<std::function<void(const ClusterPressEvent& /* event */)>>;
+  inline std::optional<std::function<void(const ClusterPressEvent& /* event */)>> create_std__optional_std__function_void_const_ClusterPressEvent_____event______(const std::function<void(const ClusterPressEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const ClusterPressEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_ClusterPressEvent_____event______(const std::optional<std::function<void(const ClusterPressEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const ClusterPressEvent& /* event */)> get_std__optional_std__function_void_const_ClusterPressEvent_____event______(const std::optional<std::function<void(const ClusterPressEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const MapError& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const MapError&)>`.
+   */
+  using Func_void_MapError = std::function<void(const MapError& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const MapError& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_MapError_Wrapper final {
+  public:
+    explicit Func_void_MapError_Wrapper(std::function<void(const MapError& /* error */)>&& func): _function(std::make_unique<std::function<void(const MapError& /* error */)>>(std::move(func))) {}
+    inline void call(MapError error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const MapError& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_MapError create_Func_void_MapError(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_MapError_Wrapper wrap_Func_void_MapError(Func_void_MapError value) noexcept {
+    return Func_void_MapError_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const MapError& /* error */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const MapError& / * error * /)>>`.
+   */
+  using std__optional_std__function_void_const_MapError_____error______ = std::optional<std::function<void(const MapError& /* error */)>>;
+  inline std::optional<std::function<void(const MapError& /* error */)>> create_std__optional_std__function_void_const_MapError_____error______(const std::function<void(const MapError& /* error */)>& value) noexcept {
+    return std::optional<std::function<void(const MapError& /* error */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_MapError_____error______(const std::optional<std::function<void(const MapError& /* error */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const MapError& /* error */)> get_std__optional_std__function_void_const_MapError_____error______(const std::optional<std::function<void(const MapError& /* error */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<Coordinate>
+  /**
+   * Specialized version of `std::vector<Coordinate>`.
+   */
+  using std__vector_Coordinate_ = std::vector<Coordinate>;
+  inline std::vector<Coordinate> create_std__vector_Coordinate_(size_t size) noexcept {
+    std::vector<Coordinate> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<EdgePadding>
+  /**
+   * Specialized version of `std::optional<EdgePadding>`.
+   */
+  using std__optional_EdgePadding_ = std::optional<EdgePadding>;
+  inline std::optional<EdgePadding> create_std__optional_EdgePadding_(const EdgePadding& value) noexcept {
+    return std::optional<EdgePadding>(value);
+  }
+  inline bool has_value_std__optional_EdgePadding_(const std::optional<EdgePadding>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline EdgePadding get_std__optional_EdgePadding_(const std::optional<EdgePadding>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<Camera>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<Camera>>`.
+   */
+  using std__shared_ptr_Promise_Camera__ = std::shared_ptr<Promise<Camera>>;
+  inline std::shared_ptr<Promise<Camera>> create_std__shared_ptr_Promise_Camera__() noexcept {
+    return Promise<Camera>::create();
+  }
+  inline PromiseHolder<Camera> wrap_std__shared_ptr_Promise_Camera__(std::shared_ptr<Promise<Camera>> promise) noexcept {
+    return PromiseHolder<Camera>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const Camera& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const Camera&)>`.
+   */
+  using Func_void_Camera = std::function<void(const Camera& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Camera& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_Camera_Wrapper final {
+  public:
+    explicit Func_void_Camera_Wrapper(std::function<void(const Camera& /* result */)>&& func): _function(std::make_unique<std::function<void(const Camera& /* result */)>>(std::move(func))) {}
+    inline void call(Camera result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const Camera& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Camera create_Func_void_Camera(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Camera_Wrapper wrap_Func_void_Camera(Func_void_Camera value) noexcept {
+    return Func_void_Camera_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::shared_ptr<Promise<MapBoundaries>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<MapBoundaries>>`.
+   */
+  using std__shared_ptr_Promise_MapBoundaries__ = std::shared_ptr<Promise<MapBoundaries>>;
+  inline std::shared_ptr<Promise<MapBoundaries>> create_std__shared_ptr_Promise_MapBoundaries__() noexcept {
+    return Promise<MapBoundaries>::create();
+  }
+  inline PromiseHolder<MapBoundaries> wrap_std__shared_ptr_Promise_MapBoundaries__(std::shared_ptr<Promise<MapBoundaries>> promise) noexcept {
+    return PromiseHolder<MapBoundaries>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const MapBoundaries& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const MapBoundaries&)>`.
+   */
+  using Func_void_MapBoundaries = std::function<void(const MapBoundaries& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const MapBoundaries& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_MapBoundaries_Wrapper final {
+  public:
+    explicit Func_void_MapBoundaries_Wrapper(std::function<void(const MapBoundaries& /* result */)>&& func): _function(std::make_unique<std::function<void(const MapBoundaries& /* result */)>>(std::move(func))) {}
+    inline void call(MapBoundaries result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const MapBoundaries& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_MapBoundaries create_Func_void_MapBoundaries(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_MapBoundaries_Wrapper wrap_Func_void_MapBoundaries(Func_void_MapBoundaries value) noexcept {
+    return Func_void_MapBoundaries_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<ImageMarkerConfig>
+  /**
+   * Specialized version of `std::optional<ImageMarkerConfig>`.
+   */
+  using std__optional_ImageMarkerConfig_ = std::optional<ImageMarkerConfig>;
+  inline std::optional<ImageMarkerConfig> create_std__optional_ImageMarkerConfig_(const ImageMarkerConfig& value) noexcept {
+    return std::optional<ImageMarkerConfig>(value);
+  }
+  inline bool has_value_std__optional_ImageMarkerConfig_(const std::optional<ImageMarkerConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ImageMarkerConfig get_std__optional_ImageMarkerConfig_(const std::optional<ImageMarkerConfig>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::variant<std::string, MarkerColor>>
+  /**
+   * Specialized version of `std::optional<std::variant<std::string, MarkerColor>>`.
+   */
+  using std__optional_std__variant_std__string__MarkerColor__ = std::optional<std::variant<std::string, MarkerColor>>;
+  inline std::optional<std::variant<std::string, MarkerColor>> create_std__optional_std__variant_std__string__MarkerColor__(const std::variant<std::string, MarkerColor>& value) noexcept {
+    return std::optional<std::variant<std::string, MarkerColor>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_std__string__MarkerColor__(const std::optional<std::variant<std::string, MarkerColor>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<std::string, MarkerColor> get_std__optional_std__variant_std__string__MarkerColor__(const std::optional<std::variant<std::string, MarkerColor>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<PriceMarkerStyle>
+  /**
+   * Specialized version of `std::optional<PriceMarkerStyle>`.
+   */
+  using std__optional_PriceMarkerStyle_ = std::optional<PriceMarkerStyle>;
+  inline std::optional<PriceMarkerStyle> create_std__optional_PriceMarkerStyle_(const PriceMarkerStyle& value) noexcept {
+    return std::optional<PriceMarkerStyle>(value);
+  }
+  inline bool has_value_std__optional_PriceMarkerStyle_(const std::optional<PriceMarkerStyle>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PriceMarkerStyle get_std__optional_PriceMarkerStyle_(const std::optional<PriceMarkerStyle>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<MarkerData>
+  /**
+   * Specialized version of `std::vector<MarkerData>`.
+   */
+  using std__vector_MarkerData_ = std::vector<MarkerData>;
+  inline std::vector<MarkerData> create_std__vector_MarkerData_(size_t size) noexcept {
+    std::vector<MarkerData> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNitroMapSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridNitroMapSpec>`.
+   */
+  using std__shared_ptr_HybridNitroMapSpec_ = std::shared_ptr<HybridNitroMapSpec>;
+  std::shared_ptr<HybridNitroMapSpec> create_std__shared_ptr_HybridNitroMapSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroMapSpec_(std__shared_ptr_HybridNitroMapSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNitroMapSpec>
+  using std__weak_ptr_HybridNitroMapSpec_ = std::weak_ptr<HybridNitroMapSpec>;
+  inline std__weak_ptr_HybridNitroMapSpec_ weakify_std__shared_ptr_HybridNitroMapSpec_(const std::shared_ptr<HybridNitroMapSpec>& strong) noexcept { return strong; }
+  
+  // 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);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<Camera>>>
+  using Result_std__shared_ptr_Promise_Camera___ = Result<std::shared_ptr<Promise<Camera>>>;
+  inline Result_std__shared_ptr_Promise_Camera___ create_Result_std__shared_ptr_Promise_Camera___(const std::shared_ptr<Promise<Camera>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<Camera>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_Camera___ create_Result_std__shared_ptr_Promise_Camera___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<Camera>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<MapBoundaries>>>
+  using Result_std__shared_ptr_Promise_MapBoundaries___ = Result<std::shared_ptr<Promise<MapBoundaries>>>;
+  inline Result_std__shared_ptr_Promise_MapBoundaries___ create_Result_std__shared_ptr_Promise_MapBoundaries___(const std::shared_ptr<Promise<MapBoundaries>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<MapBoundaries>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_MapBoundaries___ create_Result_std__shared_ptr_Promise_MapBoundaries___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<MapBoundaries>>>::withError(error);
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNitroMapConfigSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridNitroMapConfigSpec>`.
+   */
+  using std__shared_ptr_HybridNitroMapConfigSpec_ = std::shared_ptr<HybridNitroMapConfigSpec>;
+  std::shared_ptr<HybridNitroMapConfigSpec> create_std__shared_ptr_HybridNitroMapConfigSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroMapConfigSpec_(std__shared_ptr_HybridNitroMapConfigSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNitroMapConfigSpec>
+  using std__weak_ptr_HybridNitroMapConfigSpec_ = std::weak_ptr<HybridNitroMapConfigSpec>;
+  inline std__weak_ptr_HybridNitroMapConfigSpec_ weakify_std__shared_ptr_HybridNitroMapConfigSpec_(const std::shared_ptr<HybridNitroMapConfigSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+
+} // namespace margelo::nitro::nitromap::bridge::swift