react-native-google-maps-plus 1.3.0-dev.1 → 1.3.0-dev.3

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

@@ -34,10 +34,16 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNIOSLocationAccuracy; }
 namespace margelo::nitro::rngooglemapsplus { struct RNIOSLocationConfig; }
 // Forward declaration of `RNIOSPermissionResult` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
+// Forward declaration of `RNIndoorBuilding` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorBuilding; }
+// Forward declaration of `RNIndoorLevel` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorLevel; }
 // Forward declaration of `RNInitialProps` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNInitialProps; }
 // Forward declaration of `RNKMLayer` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNKMLayer; }
+// Forward declaration of `RNLatLngBounds` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNLatLngBounds; }
 // Forward declaration of `RNLatLng` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNLatLng; }
 // Forward declaration of `RNLineCapType` to properly resolve imports.
@@ -74,6 +80,8 @@ namespace margelo::nitro::rngooglemapsplus { struct RNPolyline; }
 namespace margelo::nitro::rngooglemapsplus { struct RNPosition; }
 // Forward declaration of `RNRegion` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNRegion; }
+// Forward declaration of `RNSize` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNSize; }
 // Forward declaration of `RNUserInterfaceStyle` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
 
@@ -97,9 +105,12 @@ namespace RNGoogleMapsPlus { class HybridRNGoogleMapsPlusViewSpec_cxx; }
 #include "RNIOSLocationAccuracy.hpp"
 #include "RNIOSLocationConfig.hpp"
 #include "RNIOSPermissionResult.hpp"
+#include "RNIndoorBuilding.hpp"
+#include "RNIndoorLevel.hpp"
 #include "RNInitialProps.hpp"
 #include "RNKMLayer.hpp"
 #include "RNLatLng.hpp"
+#include "RNLatLngBounds.hpp"
 #include "RNLineCapType.hpp"
 #include "RNLineJoinType.hpp"
 #include "RNLocation.hpp"
@@ -117,6 +128,7 @@ namespace RNGoogleMapsPlus { class HybridRNGoogleMapsPlusViewSpec_cxx; }
 #include "RNPolyline.hpp"
 #include "RNPosition.hpp"
 #include "RNRegion.hpp"
+#include "RNSize.hpp"
 #include "RNUserInterfaceStyle.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -1033,6 +1045,91 @@ namespace margelo::nitro::rngooglemapsplus::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::vector<RNIndoorLevel>
+  /**
+   * Specialized version of `std::vector<RNIndoorLevel>`.
+   */
+  using std__vector_RNIndoorLevel_ = std::vector<RNIndoorLevel>;
+  inline std::vector<RNIndoorLevel> create_std__vector_RNIndoorLevel_(size_t size) noexcept {
+    std::vector<RNIndoorLevel> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>
+  /**
+   * Specialized version of `std::function<void(const RNIndoorBuilding&)>`.
+   */
+  using Func_void_RNIndoorBuilding = std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RNIndoorBuilding& / * indoorBuilding * /)>`, this can be used from Swift.
+   */
+  class Func_void_RNIndoorBuilding_Wrapper final {
+  public:
+    explicit Func_void_RNIndoorBuilding_Wrapper(std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>&& func): _function(std::make_unique<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>(std::move(func))) {}
+    inline void call(RNIndoorBuilding indoorBuilding) const noexcept {
+      _function->operator()(indoorBuilding);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RNIndoorBuilding create_Func_void_RNIndoorBuilding(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_RNIndoorBuilding_Wrapper wrap_Func_void_RNIndoorBuilding(Func_void_RNIndoorBuilding value) noexcept {
+    return Func_void_RNIndoorBuilding_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RNIndoorBuilding& / * indoorBuilding * /)>>`.
+   */
+  using std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______ = std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>;
+  inline std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>> create_std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______(const std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>& value) noexcept {
+    return std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______(const std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RNIndoorBuilding& /* indoorBuilding */)> get_std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______(const std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const RNIndoorLevel& /* indoorLevel */)>
+  /**
+   * Specialized version of `std::function<void(const RNIndoorLevel&)>`.
+   */
+  using Func_void_RNIndoorLevel = std::function<void(const RNIndoorLevel& /* indoorLevel */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RNIndoorLevel& / * indoorLevel * /)>`, this can be used from Swift.
+   */
+  class Func_void_RNIndoorLevel_Wrapper final {
+  public:
+    explicit Func_void_RNIndoorLevel_Wrapper(std::function<void(const RNIndoorLevel& /* indoorLevel */)>&& func): _function(std::make_unique<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>(std::move(func))) {}
+    inline void call(RNIndoorLevel indoorLevel) const noexcept {
+      _function->operator()(indoorLevel);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RNIndoorLevel& /* indoorLevel */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RNIndoorLevel create_Func_void_RNIndoorLevel(void* _Nonnull swiftClosureWrapper) noexcept;
+  inline Func_void_RNIndoorLevel_Wrapper wrap_Func_void_RNIndoorLevel(Func_void_RNIndoorLevel value) noexcept {
+    return Func_void_RNIndoorLevel_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RNIndoorLevel& / * indoorLevel * /)>>`.
+   */
+  using std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______ = std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>;
+  inline std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>> create_std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______(const std::function<void(const RNIndoorLevel& /* indoorLevel */)>& value) noexcept {
+    return std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______(const std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RNIndoorLevel& /* indoorLevel */)> get_std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______(const std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>
   /**
    * Specialized version of `std::function<void(const RNRegion&, const RNCamera&, bool)>`.
@@ -1070,6 +1167,48 @@ namespace margelo::nitro::rngooglemapsplus::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<RNLatLngBounds>
+  /**
+   * Specialized version of `std::optional<RNLatLngBounds>`.
+   */
+  using std__optional_RNLatLngBounds_ = std::optional<RNLatLngBounds>;
+  inline std::optional<RNLatLngBounds> create_std__optional_RNLatLngBounds_(const RNLatLngBounds& value) noexcept {
+    return std::optional<RNLatLngBounds>(value);
+  }
+  inline bool has_value_std__optional_RNLatLngBounds_(const std::optional<RNLatLngBounds>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline RNLatLngBounds get_std__optional_RNLatLngBounds_(const std::optional<RNLatLngBounds>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<std::string>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<std::string>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_std__string___ = std::shared_ptr<Promise<std::optional<std::string>>>;
+  inline std::shared_ptr<Promise<std::optional<std::string>>> create_std__shared_ptr_Promise_std__optional_std__string___() noexcept {
+    return Promise<std::optional<std::string>>::create();
+  }
+  inline PromiseHolder<std::optional<std::string>> wrap_std__shared_ptr_Promise_std__optional_std__string___(std::shared_ptr<Promise<std::optional<std::string>>> promise) noexcept {
+    return PromiseHolder<std::optional<std::string>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::optional<RNSize>
+  /**
+   * Specialized version of `std::optional<RNSize>`.
+   */
+  using std__optional_RNSize_ = std::optional<RNSize>;
+  inline std::optional<RNSize> create_std__optional_RNSize_(const RNSize& value) noexcept {
+    return std::optional<RNSize>(value);
+  }
+  inline bool has_value_std__optional_RNSize_(const std::optional<RNSize>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline RNSize get_std__optional_RNSize_(const std::optional<RNSize>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridRNGoogleMapsPlusViewSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridRNGoogleMapsPlusViewSpec>`.
@@ -1081,5 +1220,14 @@ namespace margelo::nitro::rngooglemapsplus::bridge::swift {
   // pragma MARK: std::weak_ptr<HybridRNGoogleMapsPlusViewSpec>
   using std__weak_ptr_HybridRNGoogleMapsPlusViewSpec_ = std::weak_ptr<HybridRNGoogleMapsPlusViewSpec>;
   inline std__weak_ptr_HybridRNGoogleMapsPlusViewSpec_ weakify_std__shared_ptr_HybridRNGoogleMapsPlusViewSpec_(const std::shared_ptr<HybridRNGoogleMapsPlusViewSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::string>>>>
+  using Result_std__shared_ptr_Promise_std__optional_std__string____ = Result<std::shared_ptr<Promise<std::optional<std::string>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::shared_ptr<Promise<std::optional<std::string>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::rngooglemapsplus::bridge::swift

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

@@ -34,10 +34,16 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNIOSLocationAccuracy; }
 namespace margelo::nitro::rngooglemapsplus { struct RNIOSLocationConfig; }
 // Forward declaration of `RNIOSPermissionResult` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
+// Forward declaration of `RNIndoorBuilding` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorBuilding; }
+// Forward declaration of `RNIndoorLevel` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorLevel; }
 // Forward declaration of `RNInitialProps` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNInitialProps; }
 // Forward declaration of `RNKMLayer` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNKMLayer; }
+// Forward declaration of `RNLatLngBounds` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNLatLngBounds; }
 // Forward declaration of `RNLatLng` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNLatLng; }
 // Forward declaration of `RNLineCapType` to properly resolve imports.
@@ -74,6 +80,14 @@ namespace margelo::nitro::rngooglemapsplus { struct RNPolyline; }
 namespace margelo::nitro::rngooglemapsplus { struct RNPosition; }
 // Forward declaration of `RNRegion` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNRegion; }
+// Forward declaration of `RNSize` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNSize; }
+// Forward declaration of `RNSnapshotFormat` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNSnapshotFormat; }
+// Forward declaration of `RNSnapshotOptions` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNSnapshotOptions; }
+// Forward declaration of `RNSnapshotResultType` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNSnapshotResultType; }
 // Forward declaration of `RNUserInterfaceStyle` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
 
@@ -91,9 +105,12 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
 #include "RNIOSLocationAccuracy.hpp"
 #include "RNIOSLocationConfig.hpp"
 #include "RNIOSPermissionResult.hpp"
+#include "RNIndoorBuilding.hpp"
+#include "RNIndoorLevel.hpp"
 #include "RNInitialProps.hpp"
 #include "RNKMLayer.hpp"
 #include "RNLatLng.hpp"
+#include "RNLatLngBounds.hpp"
 #include "RNLineCapType.hpp"
 #include "RNLineJoinType.hpp"
 #include "RNLocation.hpp"
@@ -111,6 +128,10 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNUserInterfaceStyle; }
 #include "RNPolyline.hpp"
 #include "RNPosition.hpp"
 #include "RNRegion.hpp"
+#include "RNSize.hpp"
+#include "RNSnapshotFormat.hpp"
+#include "RNSnapshotOptions.hpp"
+#include "RNSnapshotResultType.hpp"
 #include "RNUserInterfaceStyle.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>

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

@@ -68,8 +68,22 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNMapErrorCode; }
 namespace margelo::nitro::rngooglemapsplus { struct RNLocation; }
 // Forward declaration of `RNLocationErrorCode` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { enum class RNLocationErrorCode; }
+// Forward declaration of `RNIndoorBuilding` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorBuilding; }
+// Forward declaration of `RNIndoorLevel` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNIndoorLevel; }
 // Forward declaration of `RNRegion` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNRegion; }
+// Forward declaration of `RNLatLngBounds` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNLatLngBounds; }
+// Forward declaration of `RNSnapshotOptions` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNSnapshotOptions; }
+// Forward declaration of `RNSize` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { struct RNSize; }
+// Forward declaration of `RNSnapshotFormat` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNSnapshotFormat; }
+// Forward declaration of `RNSnapshotResultType` to properly resolve imports.
+namespace margelo::nitro::rngooglemapsplus { enum class RNSnapshotResultType; }
 // Forward declaration of `RNLocationPermissionResult` to properly resolve imports.
 namespace margelo::nitro::rngooglemapsplus { struct RNLocationPermissionResult; }
 // Forward declaration of `RNAndroidLocationPermissionResult` to properly resolve imports.
@@ -109,9 +123,16 @@ namespace margelo::nitro::rngooglemapsplus { enum class RNIOSPermissionResult; }
 #include <functional>
 #include "RNLocation.hpp"
 #include "RNLocationErrorCode.hpp"
+#include "RNIndoorBuilding.hpp"
+#include "RNIndoorLevel.hpp"
 #include "RNRegion.hpp"
-#include "RNLocationPermissionResult.hpp"
+#include "RNLatLngBounds.hpp"
 #include <NitroModules/Promise.hpp>
+#include "RNSnapshotOptions.hpp"
+#include "RNSize.hpp"
+#include "RNSnapshotFormat.hpp"
+#include "RNSnapshotResultType.hpp"
+#include "RNLocationPermissionResult.hpp"
 #include "RNAndroidLocationPermissionResult.hpp"
 #include "RNIOSPermissionResult.hpp"
 
@@ -362,6 +383,20 @@ namespace margelo::nitro::rngooglemapsplus {
     inline void setOnMarkerDragEnd(const std::optional<std::function<void(const std::optional<std::string>& /* id */, const RNLatLng& /* location */)>>& onMarkerDragEnd) noexcept override {
       _swiftPart.setOnMarkerDragEnd(onMarkerDragEnd);
     }
+    inline std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>> getOnIndoorBuildingFocused() noexcept override {
+      auto __result = _swiftPart.getOnIndoorBuildingFocused();
+      return __result;
+    }
+    inline void setOnIndoorBuildingFocused(const std::optional<std::function<void(const RNIndoorBuilding& /* indoorBuilding */)>>& onIndoorBuildingFocused) noexcept override {
+      _swiftPart.setOnIndoorBuildingFocused(onIndoorBuildingFocused);
+    }
+    inline std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>> getOnIndoorLevelActivated() noexcept override {
+      auto __result = _swiftPart.getOnIndoorLevelActivated();
+      return __result;
+    }
+    inline void setOnIndoorLevelActivated(const std::optional<std::function<void(const RNIndoorLevel& /* indoorLevel */)>>& onIndoorLevelActivated) noexcept override {
+      _swiftPart.setOnIndoorLevelActivated(onIndoorLevelActivated);
+    }
     inline std::optional<std::function<void(const RNRegion& /* region */, const RNCamera& /* camera */, bool /* isGesture */)>> getOnCameraChangeStart() noexcept override {
       auto __result = _swiftPart.getOnCameraChangeStart();
       return __result;
@@ -386,18 +421,38 @@ namespace margelo::nitro::rngooglemapsplus {
 
   public:
     // Methods
-    inline void setCamera(const RNCamera& camera, std::optional<bool> animated, std::optional<double> durationMS) override {
-      auto __result = _swiftPart.setCamera(camera, animated, durationMS);
+    inline void setCamera(const RNCamera& camera, std::optional<bool> animated, std::optional<double> durationMs) override {
+      auto __result = _swiftPart.setCamera(camera, animated, durationMs);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setCameraToCoordinates(const std::vector<RNLatLng>& coordinates, const std::optional<RNMapPadding>& padding, std::optional<bool> animated, std::optional<double> durationMs) override {
+      auto __result = _swiftPart.setCameraToCoordinates(coordinates, padding, animated, durationMs);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setCameraBounds(const std::optional<RNLatLngBounds>& bounds) override {
+      auto __result = _swiftPart.setCameraBounds(bounds);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
-    inline void setCameraToCoordinates(const std::vector<RNLatLng>& coordinates, const std::optional<RNMapPadding>& padding, std::optional<bool> animated, std::optional<double> durationMS) override {
-      auto __result = _swiftPart.setCameraToCoordinates(coordinates, padding, animated, durationMS);
+    inline void animateToBounds(const RNLatLngBounds& bounds, std::optional<double> padding, std::optional<double> durationMs, std::optional<bool> lockBounds) override {
+      auto __result = _swiftPart.animateToBounds(bounds, padding, durationMs, lockBounds);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
+    inline std::shared_ptr<Promise<std::optional<std::string>>> snapshot(const RNSnapshotOptions& options) override {
+      auto __result = _swiftPart.snapshot(options);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void showLocationDialog() override {
       auto __result = _swiftPart.showLocationDialog();
       if (__result.hasError()) [[unlikely]] {

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

@@ -221,6 +221,16 @@ using namespace margelo::nitro::rngooglemapsplus::views;
     swiftPart.setOnMarkerDragEnd(newViewProps.onMarkerDragEnd.value);
     newViewProps.onMarkerDragEnd.isDirty = false;
   }
+  // onIndoorBuildingFocused: optional
+  if (newViewProps.onIndoorBuildingFocused.isDirty) {
+    swiftPart.setOnIndoorBuildingFocused(newViewProps.onIndoorBuildingFocused.value);
+    newViewProps.onIndoorBuildingFocused.isDirty = false;
+  }
+  // onIndoorLevelActivated: optional
+  if (newViewProps.onIndoorLevelActivated.isDirty) {
+    swiftPart.setOnIndoorLevelActivated(newViewProps.onIndoorLevelActivated.value);
+    newViewProps.onIndoorLevelActivated.isDirty = false;
+  }
   // onCameraChangeStart: optional
   if (newViewProps.onCameraChangeStart.isDirty) {
     swiftPart.setOnCameraChangeStart(newViewProps.onCameraChangeStart.value);

package/nitrogen/generated/ios/swift/Func_void_RNIndoorBuilding.swift

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

package/nitrogen/generated/ios/swift/Func_void_RNIndoorLevel.swift

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

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

@@ -41,13 +41,18 @@ public protocol HybridRNGoogleMapsPlusViewSpec_protocol: HybridObject, HybridVie
   var onMarkerDragStart: ((_ id: String?, _ location: RNLatLng) -> Void)? { get set }
   var onMarkerDrag: ((_ id: String?, _ location: RNLatLng) -> Void)? { get set }
   var onMarkerDragEnd: ((_ id: String?, _ location: RNLatLng) -> Void)? { get set }
+  var onIndoorBuildingFocused: ((_ indoorBuilding: RNIndoorBuilding) -> Void)? { get set }
+  var onIndoorLevelActivated: ((_ indoorLevel: RNIndoorLevel) -> Void)? { get set }
   var onCameraChangeStart: ((_ region: RNRegion, _ camera: RNCamera, _ isGesture: Bool) -> Void)? { get set }
   var onCameraChange: ((_ region: RNRegion, _ camera: RNCamera, _ isGesture: Bool) -> Void)? { get set }
   var onCameraChangeComplete: ((_ region: RNRegion, _ camera: RNCamera, _ isGesture: Bool) -> Void)? { get set }
 
   // Methods
-  func setCamera(camera: RNCamera, animated: Bool?, durationMS: Double?) throws -> Void
-  func setCameraToCoordinates(coordinates: [RNLatLng], padding: RNMapPadding?, animated: Bool?, durationMS: Double?) throws -> Void
+  func setCamera(camera: RNCamera, animated: Bool?, durationMs: Double?) throws -> Void
+  func setCameraToCoordinates(coordinates: [RNLatLng], padding: RNMapPadding?, animated: Bool?, durationMs: Double?) throws -> Void
+  func setCameraBounds(bounds: RNLatLngBounds?) throws -> Void
+  func animateToBounds(bounds: RNLatLngBounds, padding: Double?, durationMs: Double?, lockBounds: Bool?) throws -> Void
+  func snapshot(options: RNSnapshotOptions) throws -> Promise<String?>
   func showLocationDialog() throws -> Void
   func openLocationSettings() throws -> Void
   func requestLocationPermission() throws -> Promise<RNLocationPermissionResult>

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

@@ -958,6 +958,70 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
     }
   }
   
+  public final var onIndoorBuildingFocused: bridge.std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______ in
+        if let __unwrappedValue = self.__implementation.onIndoorBuildingFocused {
+          return bridge.create_std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______({ () -> bridge.Func_void_RNIndoorBuilding in
+            let __closureWrapper = Func_void_RNIndoorBuilding(__unwrappedValue)
+            return bridge.create_Func_void_RNIndoorBuilding(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onIndoorBuildingFocused = { () -> ((_ indoorBuilding: RNIndoorBuilding) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_RNIndoorBuilding_____indoorBuilding______(newValue)
+          return { () -> (RNIndoorBuilding) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_RNIndoorBuilding(__unwrapped)
+            return { (__indoorBuilding: RNIndoorBuilding) -> Void in
+              __wrappedFunction.call(__indoorBuilding)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onIndoorLevelActivated: bridge.std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______ in
+        if let __unwrappedValue = self.__implementation.onIndoorLevelActivated {
+          return bridge.create_std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______({ () -> bridge.Func_void_RNIndoorLevel in
+            let __closureWrapper = Func_void_RNIndoorLevel(__unwrappedValue)
+            return bridge.create_Func_void_RNIndoorLevel(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onIndoorLevelActivated = { () -> ((_ indoorLevel: RNIndoorLevel) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_RNIndoorLevel_____indoorLevel______(newValue)
+          return { () -> (RNIndoorLevel) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_RNIndoorLevel(__unwrapped)
+            return { (__indoorLevel: RNIndoorLevel) -> Void in
+              __wrappedFunction.call(__indoorLevel)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var onCameraChangeStart: bridge.std__optional_std__function_void_const_RNRegion_____region_____const_RNCamera_____camera_____bool____isGesture______ {
     @inline(__always)
     get {
@@ -1056,9 +1120,9 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func setCamera(camera: RNCamera, animated: bridge.std__optional_bool_, durationMS: bridge.std__optional_double_) -> bridge.Result_void_ {
+  public final func setCamera(camera: RNCamera, animated: bridge.std__optional_bool_, durationMs: bridge.std__optional_double_) -> bridge.Result_void_ {
     do {
-      try self.__implementation.setCamera(camera: camera, animated: animated.value, durationMS: durationMS.value)
+      try self.__implementation.setCamera(camera: camera, animated: animated.value, durationMs: durationMs.value)
       return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
@@ -1067,7 +1131,7 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
   }
   
   @inline(__always)
-  public final func setCameraToCoordinates(coordinates: bridge.std__vector_RNLatLng_, padding: bridge.std__optional_RNMapPadding_, animated: bridge.std__optional_bool_, durationMS: bridge.std__optional_double_) -> bridge.Result_void_ {
+  public final func setCameraToCoordinates(coordinates: bridge.std__vector_RNLatLng_, padding: bridge.std__optional_RNMapPadding_, animated: bridge.std__optional_bool_, durationMs: bridge.std__optional_double_) -> bridge.Result_void_ {
     do {
       try self.__implementation.setCameraToCoordinates(coordinates: coordinates.map({ __item in __item }), padding: { () -> RNMapPadding? in
         if bridge.has_value_std__optional_RNMapPadding_(padding) {
@@ -1076,7 +1140,25 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
         } else {
           return nil
         }
-      }(), animated: animated.value, durationMS: durationMS.value)
+      }(), animated: animated.value, durationMs: durationMs.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setCameraBounds(bounds: bridge.std__optional_RNLatLngBounds_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setCameraBounds(bounds: { () -> RNLatLngBounds? in
+        if bridge.has_value_std__optional_RNLatLngBounds_(bounds) {
+          let __unwrapped = bridge.get_std__optional_RNLatLngBounds_(bounds)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }())
       return bridge.create_Result_void_()
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
@@ -1084,6 +1166,42 @@ open class HybridRNGoogleMapsPlusViewSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func animateToBounds(bounds: RNLatLngBounds, padding: bridge.std__optional_double_, durationMs: bridge.std__optional_double_, lockBounds: bridge.std__optional_bool_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.animateToBounds(bounds: bounds, padding: padding.value, durationMs: durationMs.value, lockBounds: lockBounds.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func snapshot(options: RNSnapshotOptions) -> bridge.Result_std__shared_ptr_Promise_std__optional_std__string____ {
+    do {
+      let __result = try self.__implementation.snapshot(options: options)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__optional_std__string___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__optional_std__string___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__optional_std__string___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__optional_std__string_ in
+              if let __unwrappedValue = __result {
+                return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+              } else {
+                return .init()
+              }
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_std__string____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__optional_std__string____(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func showLocationDialog() -> bridge.Result_void_ {
     do {