react-native-google-maps-plus 1.1.0-dev.2 → 1.1.0-dev.4

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

@@ -22,6 +22,12 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNAndroidLocationPriorit
 namespace margelo::nitro::rngooglemapsplus { struct RNCamera; }
 // Forward declaration of `RNCircle` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNCircle; }
+// Forward declaration of `RNHeatmapGradient` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmapGradient; }
+// Forward declaration of `RNHeatmapPoint` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmapPoint; }
+// Forward declaration of `RNHeatmap` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmap; }
 // Forward declaration of `RNIOSLocationAccuracy` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNIOSLocationAccuracy; }
 // Forward declaration of `RNIOSLocationConfig` to properly resolve imports.
@@ -52,6 +58,8 @@ namespace margelo::nitro::rngooglemapsplus { struct RNMapPadding; }
 namespace margelo::nitro::rngooglemapsplus { enum class RNMapType; }
 // Forward declaration of `RNMapUiSettings` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNMapUiSettings; }
+// Forward declaration of `RNMapZoomConfig` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNMapZoomConfig; }
 // Forward declaration of `RNMarkerSvg` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNMarkerSvg; }
 // Forward declaration of `RNMarker` to properly resolve imports.
@@ -81,6 +89,9 @@ namespace RNGoogleMapsPlus { class HybridRNGoogleMapsPlusViewSpec_cxx; }
 #include "RNAndroidLocationPriority.hpp"
 #include "RNCamera.hpp"
 #include "RNCircle.hpp"
+#include "RNHeatmap.hpp"
+#include "RNHeatmapGradient.hpp"
+#include "RNHeatmapPoint.hpp"
 #include "RNIOSLocationAccuracy.hpp"
 #include "RNIOSLocationConfig.hpp"
 #include "RNIOSPermissionResult.hpp"
@@ -96,6 +107,7 @@ namespace RNGoogleMapsPlus { class HybridRNGoogleMapsPlusViewSpec_cxx; }
 #include "RNMapPadding.hpp"
 #include "RNMapType.hpp"
 #include "RNMapUiSettings.hpp"
+#include "RNMapZoomConfig.hpp"
 #include "RNMarker.hpp"
 #include "RNMarkerSvg.hpp"
 #include "RNPolygon.hpp"
@@ -364,6 +376,21 @@ namespace margelo::nitro::rngooglemapsplus::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<RNMapZoomConfig>
+  /**
+   * Specialized version of `std::optional<RNMapZoomConfig>`.
+   */
+  using std__optional_RNMapZoomConfig_ = std::optional<RNMapZoomConfig>;
+  inline std::optional<RNMapZoomConfig> create_std__optional_RNMapZoomConfig_(const RNMapZoomConfig& value) noexcept {
+    return std::optional<RNMapZoomConfig>(value);
+  }
+  inline bool has_value_std__optional_RNMapZoomConfig_(const std::optional<RNMapZoomConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline RNMapZoomConfig get_std__optional_RNMapZoomConfig_(const std::optional<RNMapZoomConfig>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<RNMapPadding>
   /**
    * Specialized version of `std::optional<RNMapPadding>`.
@@ -569,6 +596,80 @@ namespace margelo::nitro::rngooglemapsplus::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::vector<RNHeatmapPoint>
+  /**
+   * Specialized version of `std::vector<RNHeatmapPoint>`.
+   */
+  using std__vector_RNHeatmapPoint_ = std::vector<RNHeatmapPoint>;
+  inline std::vector<RNHeatmapPoint> create_std__vector_RNHeatmapPoint_(size_t size) noexcept {
+    std::vector<RNHeatmapPoint> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // 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::vector<double>
+  /**
+   * Specialized version of `std::vector<double>`.
+   */
+  using std__vector_double_ = std::vector<double>;
+  inline std::vector<double> create_std__vector_double_(size_t size) noexcept {
+    std::vector<double> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<RNHeatmapGradient>
+  /**
+   * Specialized version of `std::optional<RNHeatmapGradient>`.
+   */
+  using std__optional_RNHeatmapGradient_ = std::optional<RNHeatmapGradient>;
+  inline std::optional<RNHeatmapGradient> create_std__optional_RNHeatmapGradient_(const RNHeatmapGradient& value) noexcept {
+    return std::optional<RNHeatmapGradient>(value);
+  }
+  inline bool has_value_std__optional_RNHeatmapGradient_(const std::optional<RNHeatmapGradient>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline RNHeatmapGradient get_std__optional_RNHeatmapGradient_(const std::optional<RNHeatmapGradient>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<RNHeatmap>
+  /**
+   * Specialized version of `std::vector<RNHeatmap>`.
+   */
+  using std__vector_RNHeatmap_ = std::vector<RNHeatmap>;
+  inline std::vector<RNHeatmap> create_std__vector_RNHeatmap_(size_t size) noexcept {
+    std::vector<RNHeatmap> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<RNHeatmap>>
+  /**
+   * Specialized version of `std::optional<std::vector<RNHeatmap>>`.
+   */
+  using std__optional_std__vector_RNHeatmap__ = std::optional<std::vector<RNHeatmap>>;
+  inline std::optional<std::vector<RNHeatmap>> create_std__optional_std__vector_RNHeatmap__(const std::vector<RNHeatmap>& value) noexcept {
+    return std::optional<std::vector<RNHeatmap>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_RNHeatmap__(const std::optional<std::vector<RNHeatmap>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<RNHeatmap> get_std__optional_std__vector_RNHeatmap__(const std::optional<std::vector<RNHeatmap>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<RNAndroidLocationPriority>
   /**
    * Specialized version of `std::optional<RNAndroidLocationPriority>`.

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

@@ -22,6 +22,12 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNAndroidLocationPriorit
 namespace margelo::nitro::rngooglemapsplus { struct RNCamera; }
 // Forward declaration of `RNCircle` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNCircle; }
+// Forward declaration of `RNHeatmapGradient` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmapGradient; }
+// Forward declaration of `RNHeatmapPoint` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmapPoint; }
+// Forward declaration of `RNHeatmap` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmap; }
 // Forward declaration of `RNIOSLocationAccuracy` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNIOSLocationAccuracy; }
 // Forward declaration of `RNIOSLocationConfig` to properly resolve imports.
@@ -52,6 +58,8 @@ namespace margelo::nitro::rngooglemapsplus { struct RNMapPadding; }
 namespace margelo::nitro::rngooglemapsplus { enum class RNMapType; }
 // Forward declaration of `RNMapUiSettings` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNMapUiSettings; }
+// Forward declaration of `RNMapZoomConfig` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNMapZoomConfig; }
 // Forward declaration of `RNMarkerSvg` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNMarkerSvg; }
 // Forward declaration of `RNMarker` to properly resolve imports.
@@ -75,6 +83,9 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
 #include "RNAndroidLocationPriority.hpp"
 #include "RNCamera.hpp"
 #include "RNCircle.hpp"
+#include "RNHeatmap.hpp"
+#include "RNHeatmapGradient.hpp"
+#include "RNHeatmapPoint.hpp"
 #include "RNIOSLocationAccuracy.hpp"
 #include "RNIOSLocationConfig.hpp"
 #include "RNIOSPermissionResult.hpp"
@@ -90,6 +101,7 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
 #include "RNMapPadding.hpp"
 #include "RNMapType.hpp"
 #include "RNMapUiSettings.hpp"
+#include "RNMapZoomConfig.hpp"
 #include "RNMarker.hpp"
 #include "RNMarkerSvg.hpp"
 #include "RNPolygon.hpp"

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

@@ -22,6 +22,8 @@ namespace margelo::nitro::rngooglemapsplus { struct RNLatLng; }
 namespace margelo::nitro::rngooglemapsplus { struct RNMapUiSettings; }
 // Forward declaration of `RNUserInterfaceStyle` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
+// Forward declaration of `RNMapZoomConfig` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNMapZoomConfig; }
 // Forward declaration of `RNMapPadding` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNMapPadding; }
 // Forward declaration of `RNMapType` to properly resolve imports.
@@ -42,6 +44,12 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNLineCapType; }
 namespace margelo::nitro::rngooglemapsplus { enum class RNLineJoinType; }
 // Forward declaration of `RNCircle` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNCircle; }
+// Forward declaration of `RNHeatmap` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmap; }
+// Forward declaration of `RNHeatmapPoint` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmapPoint; }
+// Forward declaration of `RNHeatmapGradient` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNHeatmapGradient; }
 // Forward declaration of `RNLocationConfig` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNLocationConfig; }
 // Forward declaration of `RNAndroidLocationConfig` to properly resolve imports.
@@ -74,6 +82,7 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
 #include "RNLatLng.hpp"
 #include "RNMapUiSettings.hpp"
 #include "RNUserInterfaceStyle.hpp"
+#include "RNMapZoomConfig.hpp"
 #include "RNMapPadding.hpp"
 #include "RNMapType.hpp"
 #include "RNMarker.hpp"
@@ -85,6 +94,9 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
 #include "RNLineCapType.hpp"
 #include "RNLineJoinType.hpp"
 #include "RNCircle.hpp"
+#include "RNHeatmap.hpp"
+#include "RNHeatmapPoint.hpp"
+#include "RNHeatmapGradient.hpp"
 #include "RNLocationConfig.hpp"
 #include "RNAndroidLocationConfig.hpp"
 #include "RNAndroidLocationPriority.hpp"
@@ -193,19 +205,12 @@ namespace margelo::nitro::rngooglemapsplus {
     inline void setUserInterfaceStyle(std::optional<RNUserInterfaceStyle> userInterfaceStyle) noexcept override {
       _swiftPart.setUserInterfaceStyle(userInterfaceStyle);
     }
-    inline std::optional<double> getMinZoomLevel() noexcept override {
-      auto __result = _swiftPart.getMinZoomLevel();
+    inline std::optional<RNMapZoomConfig> getMapZoomConfig() noexcept override {
+      auto __result = _swiftPart.getMapZoomConfig();
       return __result;
     }
-    inline void setMinZoomLevel(std::optional<double> minZoomLevel) noexcept override {
-      _swiftPart.setMinZoomLevel(minZoomLevel);
-    }
-    inline std::optional<double> getMaxZoomLevel() noexcept override {
-      auto __result = _swiftPart.getMaxZoomLevel();
-      return __result;
-    }
-    inline void setMaxZoomLevel(std::optional<double> maxZoomLevel) noexcept override {
-      _swiftPart.setMaxZoomLevel(maxZoomLevel);
+    inline void setMapZoomConfig(const std::optional<RNMapZoomConfig>& mapZoomConfig) noexcept override {
+      _swiftPart.setMapZoomConfig(mapZoomConfig);
     }
     inline std::optional<RNMapPadding> getMapPadding() noexcept override {
       auto __result = _swiftPart.getMapPadding();
@@ -249,6 +254,13 @@ namespace margelo::nitro::rngooglemapsplus {
     inline void setCircles(const std::optional<std::vector<RNCircle>>& circles) noexcept override {
       _swiftPart.setCircles(circles);
     }
+    inline std::optional<std::vector<RNHeatmap>> getHeatmaps() noexcept override {
+      auto __result = _swiftPart.getHeatmaps();
+      return __result;
+    }
+    inline void setHeatmaps(const std::optional<std::vector<RNHeatmap>>& heatmaps) noexcept override {
+      _swiftPart.setHeatmaps(heatmaps);
+    }
     inline std::optional<RNLocationConfig> getLocationConfig() noexcept override {
       auto __result = _swiftPart.getLocationConfig();
       return __result;

package/nitrogen/generated/ios/c++/views/HybridRNGoogleMapsPlusViewComponent.mm

@@ -111,15 +111,10 @@ using namespace margelo::nitro::rngooglemapsplus::views;
     swiftPart.setUserInterfaceStyle(newViewProps.userInterfaceStyle.value);
     newViewProps.userInterfaceStyle.isDirty = false;
   }
-  // minZoomLevel: optional
-  if (newViewProps.minZoomLevel.isDirty) {
-    swiftPart.setMinZoomLevel(newViewProps.minZoomLevel.value);
-    newViewProps.minZoomLevel.isDirty = false;
-  }
-  // maxZoomLevel: optional
-  if (newViewProps.maxZoomLevel.isDirty) {
-    swiftPart.setMaxZoomLevel(newViewProps.maxZoomLevel.value);
-    newViewProps.maxZoomLevel.isDirty = false;
+  // mapZoomConfig: optional
+  if (newViewProps.mapZoomConfig.isDirty) {
+    swiftPart.setMapZoomConfig(newViewProps.mapZoomConfig.value);
+    newViewProps.mapZoomConfig.isDirty = false;
   }
   // mapPadding: optional
   if (newViewProps.mapPadding.isDirty) {
@@ -151,6 +146,11 @@ using namespace margelo::nitro::rngooglemapsplus::views;
     swiftPart.setCircles(newViewProps.circles.value);
     newViewProps.circles.isDirty = false;
   }
+  // heatmaps: optional
+  if (newViewProps.heatmaps.isDirty) {
+    swiftPart.setHeatmaps(newViewProps.heatmaps.value);
+    newViewProps.heatmaps.isDirty = false;
+  }
   // locationConfig: optional
   if (newViewProps.locationConfig.isDirty) {
     swiftPart.setLocationConfig(newViewProps.locationConfig.value);

package/nitrogen/generated/ios/swift/HybridRNGoogleMapsPlusViewSpec.swift

@@ -19,14 +19,14 @@ public protocol HybridRNGoogleMapsPlusViewSpec_protocol: HybridObject, HybridVie
   var indoorEnabled: Bool? { get set }
   var customMapStyle: String? { get set }
   var userInterfaceStyle: RNUserInterfaceStyle? { get set }
-  var minZoomLevel: Double? { get set }
-  var maxZoomLevel: Double? { get set }
+  var mapZoomConfig: RNMapZoomConfig? { get set }
   var mapPadding: RNMapPadding? { get set }
   var mapType: RNMapType? { get set }
   var markers: [RNMarker]? { get set }
   var polygons: [RNPolygon]? { get set }
   var polylines: [RNPolyline]? { get set }
   var circles: [RNCircle]? { get set }
+  var heatmaps: [RNHeatmap]? { get set }
   var locationConfig: RNLocationConfig? { get set }
   var onMapError: ((_ error: RNMapErrorCode) -> Void)? { get set }
   var onMapReady: ((_ ready: Bool) -> Void)? { get set }

package/nitrogen/generated/ios/swift/HybridRNGoogleMapsPlusViewSpec_cxx.swift

@@ -263,12 +263,12 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
     }
   }
   
-  public final var minZoomLevel: bridge.std__optional_double_ {
+  public final var mapZoomConfig: bridge.std__optional_RNMapZoomConfig_ {
     @inline(__always)
     get {
-      return { () -> bridge.std__optional_double_ in
-        if let __unwrappedValue = self.__implementation.minZoomLevel {
-          return bridge.create_std__optional_double_(__unwrappedValue)
+      return { () -> bridge.std__optional_RNMapZoomConfig_ in
+        if let __unwrappedValue = self.__implementation.mapZoomConfig {
+          return bridge.create_std__optional_RNMapZoomConfig_(__unwrappedValue)
         } else {
           return .init()
         }
@@ -276,25 +276,15 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
     }
     @inline(__always)
     set {
-      self.__implementation.minZoomLevel = newValue.value
-    }
-  }
-  
-  public final var maxZoomLevel: bridge.std__optional_double_ {
-    @inline(__always)
-    get {
-      return { () -> bridge.std__optional_double_ in
-        if let __unwrappedValue = self.__implementation.maxZoomLevel {
-          return bridge.create_std__optional_double_(__unwrappedValue)
+      self.__implementation.mapZoomConfig = { () -> RNMapZoomConfig? in
+        if bridge.has_value_std__optional_RNMapZoomConfig_(newValue) {
+          let __unwrapped = bridge.get_std__optional_RNMapZoomConfig_(newValue)
+          return __unwrapped
         } else {
-          return .init()
+          return nil
         }
       }()
     }
-    @inline(__always)
-    set {
-      self.__implementation.maxZoomLevel = newValue.value
-    }
   }
   
   public final var mapPadding: bridge.std__optional_RNMapPadding_ {
@@ -458,6 +448,36 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
     }
   }
   
+  public final var heatmaps: bridge.std__optional_std__vector_RNHeatmap__ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__vector_RNHeatmap__ in
+        if let __unwrappedValue = self.__implementation.heatmaps {
+          return bridge.create_std__optional_std__vector_RNHeatmap__({ () -> bridge.std__vector_RNHeatmap_ in
+            var __vector = bridge.create_std__vector_RNHeatmap_(__unwrappedValue.count)
+            for __item in __unwrappedValue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.heatmaps = { () -> [RNHeatmap]? in
+        if bridge.has_value_std__optional_std__vector_RNHeatmap__(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__vector_RNHeatmap__(newValue)
+          return __unwrapped.map({ __item in __item })
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var locationConfig: bridge.std__optional_RNLocationConfig_ {
     @inline(__always)
     get {

package/nitrogen/generated/ios/swift/RNCircle.swift

@@ -18,7 +18,7 @@ public extension RNCircle {
   /**
    * Create a new instance of `RNCircle`.
    */
-  init(id: String, pressable: Bool?, zIndex: Double?, center: RNLatLng, radius: Double?, strokeWidth: Double?, strokeColor: String?, fillColor: String?) {
+  init(id: String, pressable: Bool?, zIndex: Double?, center: RNLatLng, radius: Double, strokeWidth: Double?, strokeColor: String?, fillColor: String?) {
     self.init(std.string(id), { () -> bridge.std__optional_bool_ in
       if let __unwrappedValue = pressable {
         return bridge.create_std__optional_bool_(__unwrappedValue)
@@ -31,13 +31,7 @@ public extension RNCircle {
       } else {
         return .init()
       }
-    }(), center, { () -> bridge.std__optional_double_ in
-      if let __unwrappedValue = radius {
-        return bridge.create_std__optional_double_(__unwrappedValue)
-      } else {
-        return .init()
-      }
-    }(), { () -> bridge.std__optional_double_ in
+    }(), center, radius, { () -> bridge.std__optional_double_ in
       if let __unwrappedValue = strokeWidth {
         return bridge.create_std__optional_double_(__unwrappedValue)
       } else {
@@ -114,20 +108,14 @@ public extension RNCircle {
     }
   }
   
-  var radius: Double? {
+  var radius: Double {
     @inline(__always)
     get {
-      return self.__radius.value
+      return self.__radius
     }
     @inline(__always)
     set {
-      self.__radius = { () -> bridge.std__optional_double_ in
-        if let __unwrappedValue = newValue {
-          return bridge.create_std__optional_double_(__unwrappedValue)
-        } else {
-          return .init()
-        }
-      }()
+      self.__radius = newValue
     }
   }
   

package/nitrogen/generated/ios/swift/RNHeatmap.swift

@@ -0,0 +1,180 @@
+///
+/// RNHeatmap.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `RNHeatmap`, backed by a C++ struct.
+ */
+public typealias RNHeatmap = margelo.nitro.rngooglemapsplus.RNHeatmap
+
+public extension RNHeatmap {
+  private typealias bridge = margelo.nitro.rngooglemapsplus.bridge.swift
+
+  /**
+   * Create a new instance of `RNHeatmap`.
+   */
+  init(id: String, pressable: Bool?, zIndex: Double?, weightedData: [RNHeatmapPoint], radius: Double?, opacity: Double?, gradient: RNHeatmapGradient?) {
+    self.init(std.string(id), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = pressable {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = zIndex {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__vector_RNHeatmapPoint_ in
+      var __vector = bridge.create_std__vector_RNHeatmapPoint_(weightedData.count)
+      for __item in weightedData {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = radius {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = opacity {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_RNHeatmapGradient_ in
+      if let __unwrappedValue = gradient {
+        return bridge.create_std__optional_RNHeatmapGradient_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var id: String {
+    @inline(__always)
+    get {
+      return String(self.__id)
+    }
+    @inline(__always)
+    set {
+      self.__id = std.string(newValue)
+    }
+  }
+  
+  var pressable: Bool? {
+    @inline(__always)
+    get {
+      return self.__pressable.value
+    }
+    @inline(__always)
+    set {
+      self.__pressable = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var zIndex: Double? {
+    @inline(__always)
+    get {
+      return self.__zIndex.value
+    }
+    @inline(__always)
+    set {
+      self.__zIndex = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var weightedData: [RNHeatmapPoint] {
+    @inline(__always)
+    get {
+      return self.__weightedData.map({ __item in __item })
+    }
+    @inline(__always)
+    set {
+      self.__weightedData = { () -> bridge.std__vector_RNHeatmapPoint_ in
+        var __vector = bridge.create_std__vector_RNHeatmapPoint_(newValue.count)
+        for __item in newValue {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+    }
+  }
+  
+  var radius: Double? {
+    @inline(__always)
+    get {
+      return self.__radius.value
+    }
+    @inline(__always)
+    set {
+      self.__radius = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var opacity: Double? {
+    @inline(__always)
+    get {
+      return self.__opacity.value
+    }
+    @inline(__always)
+    set {
+      self.__opacity = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var gradient: RNHeatmapGradient? {
+    @inline(__always)
+    get {
+      return { () -> RNHeatmapGradient? in
+        if bridge.has_value_std__optional_RNHeatmapGradient_(self.__gradient) {
+          let __unwrapped = bridge.get_std__optional_RNHeatmapGradient_(self.__gradient)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__gradient = { () -> bridge.std__optional_RNHeatmapGradient_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_RNHeatmapGradient_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}